author | unc0rr |
Wed, 03 Dec 2014 00:07:33 +0300 | |
branch | qmlfrontend |
changeset 10606 | 8e95911cb86b |
parent 10108 | c68cf030eded |
child 10637 | 13a5dd92ebf9 |
permissions | -rw-r--r-- |
71 | 1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
9998 | 3 |
* Copyright (c) 2004-2014 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 |
|
10108
c68cf030eded
update FSF address. note: two sdl include files (by Sam Lantinga) still have the old FSF address in their copyright - but I ain't gonna touch their copyright headers
sheepluva
parents:
10097
diff
changeset
|
16 |
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
71 | 17 |
*) |
18 |
||
2630 | 19 |
{$INCLUDE "options.inc"} |
20 |
||
4 | 21 |
unit uAIAmmoTests; |
22 |
interface |
|
9137
d987230b85ed
fixed all engine compilation hints and notes (that I could see)
sheepluva
parents:
9080
diff
changeset
|
23 |
uses uConsts, uFloat, uTypes, uAIMisc; |
8924 | 24 |
const |
9495
2fc346fadae3
- AI quickly shoots with desert eagle till hits the target
unc0rr
parents:
9145
diff
changeset
|
25 |
amtest_Rare = $00000001; // check only several positions |
2fc346fadae3
- AI quickly shoots with desert eagle till hits the target
unc0rr
parents:
9145
diff
changeset
|
26 |
amtest_NoTarget = $00000002; // each pos, but no targetting |
2fc346fadae3
- AI quickly shoots with desert eagle till hits the target
unc0rr
parents:
9145
diff
changeset
|
27 |
amtest_MultipleAttacks = $00000004; // test could result in multiple attacks, set AttacksNum |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
28 |
|
7078
a3408d9ba5ad
AI can't use cWindSpeedf since it now does a smooth transition
nemo
parents:
7041
diff
changeset
|
29 |
var windSpeed: real; |
a3408d9ba5ad
AI can't use cWindSpeedf since it now does a smooth transition
nemo
parents:
7041
diff
changeset
|
30 |
|
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
31 |
type TAttackParams = record |
9495
2fc346fadae3
- AI quickly shoots with desert eagle till hits the target
unc0rr
parents:
9145
diff
changeset
|
32 |
Time, AttacksNum: Longword; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
33 |
Angle, Power: LongInt; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
34 |
ExplX, ExplY, ExplR: LongInt; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
35 |
AttackPutX, AttackPutY: LongInt; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
36 |
end; |
433 | 37 |
|
8959 | 38 |
function TestBazooka(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
39 |
function TestSnowball(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
|
40 |
function TestGrenade(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
|
41 |
function TestMolotov(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
|
42 |
function TestClusterBomb(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
|
43 |
function TestWatermelon(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
|
44 |
function TestDrillRocket(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
|
45 |
function TestMortar(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
|
46 |
function TestShotgun(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
|
47 |
function TestDesertEagle(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
|
48 |
function TestSniperRifle(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
|
49 |
function TestBaseballBat(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
|
50 |
function TestFirePunch(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
|
51 |
function TestWhip(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
|
52 |
function TestKamikaze(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
|
53 |
function TestAirAttack(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
|
54 |
function TestTeleport(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
|
55 |
function TestHammer(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
|
56 |
function TestCake(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
|
9722
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
57 |
function TestDynamite(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
58 |
|
8959 | 59 |
type TAmmoTestProc = function (Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
60 |
TAmmoTest = record |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
61 |
proc: TAmmoTestProc; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
62 |
flags: Longword; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
63 |
end; |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
64 |
|
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
65 |
const AmmoTests: array[TAmmoType] of TAmmoTest = |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
66 |
( |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
67 |
(proc: nil; flags: 0), // amNothing |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
68 |
(proc: @TestGrenade; flags: 0), // amGrenade |
2978 | 69 |
(proc: @TestClusterBomb; flags: 0), // amClusterBomb |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
70 |
(proc: @TestBazooka; flags: 0), // amBazooka |
3080 | 71 |
(proc: nil; flags: 0), // amBee |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
72 |
(proc: @TestShotgun; flags: 0), // amShotgun |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
73 |
(proc: nil; flags: 0), // amPickHammer |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
74 |
(proc: nil; flags: 0), // amSkip |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
75 |
(proc: nil; flags: 0), // amRope |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
76 |
(proc: nil; flags: 0), // amMine |
9495
2fc346fadae3
- AI quickly shoots with desert eagle till hits the target
unc0rr
parents:
9145
diff
changeset
|
77 |
(proc: @TestDesertEagle; flags: amtest_MultipleAttacks), // amDEagle |
9722
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
78 |
(proc: @TestDynamite; flags: amtest_NoTarget), // amDynamite |
7178
c61cfc9eb29d
Don't make unnecessary calls to TestWhip, TestFirePunch, TestBaseballBat and TestHammer functions as they have no need to take Targ parameter into account and thus may only be called once per position
unc0rr
parents:
7161
diff
changeset
|
79 |
(proc: @TestFirePunch; flags: amtest_NoTarget), // amFirePunch |
c61cfc9eb29d
Don't make unnecessary calls to TestWhip, TestFirePunch, TestBaseballBat and TestHammer functions as they have no need to take Targ parameter into account and thus may only be called once per position
unc0rr
parents:
7161
diff
changeset
|
80 |
(proc: @TestWhip; flags: amtest_NoTarget), // amWhip |
c61cfc9eb29d
Don't make unnecessary calls to TestWhip, TestFirePunch, TestBaseballBat and TestHammer functions as they have no need to take Targ parameter into account and thus may only be called once per position
unc0rr
parents:
7161
diff
changeset
|
81 |
(proc: @TestBaseballBat; flags: amtest_NoTarget), // amBaseballBat |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
82 |
(proc: nil; flags: 0), // amParachute |
7789
838d2e06c377
Check cake and air attack again if walked far from initial position (not tested)
unc0rr
parents:
7760
diff
changeset
|
83 |
(proc: @TestAirAttack; flags: amtest_Rare), // amAirAttack |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
84 |
(proc: nil; flags: 0), // amMineStrike |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
85 |
(proc: nil; flags: 0), // amBlowTorch |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
86 |
(proc: nil; flags: 0), // amGirder |
3739 | 87 |
(proc: nil; flags: 0), // amTeleport |
88 |
//(proc: @TestTeleport; flags: amtest_OnTurn), // amTeleport |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
89 |
(proc: nil; flags: 0), // amSwitch |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
90 |
(proc: @TestMortar; flags: 0), // amMortar |
7471 | 91 |
(proc: @TestKamikaze; flags: 0), // amKamikaze |
7789
838d2e06c377
Check cake and air attack again if walked far from initial position (not tested)
unc0rr
parents:
7760
diff
changeset
|
92 |
(proc: @TestCake; flags: amtest_Rare or amtest_NoTarget), // amCake |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
93 |
(proc: nil; flags: 0), // amSeduction |
2973
b51a0f57cd43
Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents:
2948
diff
changeset
|
94 |
(proc: @TestWatermelon; flags: 0), // amWatermelon |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
95 |
(proc: nil; flags: 0), // amHellishBomb |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
96 |
(proc: nil; flags: 0), // amNapalm |
8033
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
97 |
(proc: @TestDrillRocket; flags: 0), // amDrill |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
98 |
(proc: nil; flags: 0), // amBallgun |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
99 |
(proc: nil; flags: 0), // amRCPlane |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
100 |
(proc: nil; flags: 0), // amLowGravity |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
101 |
(proc: nil; flags: 0), // amExtraDamage |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
102 |
(proc: nil; flags: 0), // amInvulnerable |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
103 |
(proc: nil; flags: 0), // amExtraTime |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
104 |
(proc: nil; flags: 0), // amLaserSight |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
105 |
(proc: nil; flags: 0), // amVampiric |
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
106 |
(proc: @TestSniperRifle; flags: 0), // amSniperRifle |
3342
b4f01613dcd7
Some initial stubs for portal just so Tiy will quit nagging. Also let folks know what approximation of physics I plan to try, here.
nemo
parents:
3236
diff
changeset
|
107 |
(proc: nil; flags: 0), // amJetpack |
3066
5c0efa437728
Enable birdy. Has egg bombing. Eggs should possibly have a dX component. No poison yet, no egg sprite.
nemo
parents:
3022
diff
changeset
|
108 |
(proc: @TestMolotov; flags: 0), // amMolotov |
3350 | 109 |
(proc: nil; flags: 0), // amBirdy |
110 |
(proc: nil; flags: 0), // amPortalGun |
|
3382 | 111 |
(proc: nil; flags: 0), // amPiano |
3384 | 112 |
(proc: @TestGrenade; flags: 0), // amGasBomb |
3476
1ec68b8d3bd1
Henek adds a flamethrower, updates some translations, and tweaks how fire works.
nemo
parents:
3439
diff
changeset
|
113 |
(proc: @TestShotgun; flags: 0), // amSineGun |
3710 | 114 |
(proc: nil; flags: 0), // amFlamethrower |
3717 | 115 |
(proc: @TestGrenade; flags: 0), // amSMine |
7178
c61cfc9eb29d
Don't make unnecessary calls to TestWhip, TestFirePunch, TestBaseballBat and TestHammer functions as they have no need to take Targ parameter into account and thus may only be called once per position
unc0rr
parents:
7161
diff
changeset
|
116 |
(proc: @TestHammer; flags: amtest_NoTarget), // amHammer |
4246
e5cb885492df
drillstrike! might require the drill patch to improve behavior
koda
parents:
4226
diff
changeset
|
117 |
(proc: nil; flags: 0), // amResurrector |
4881
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4580
diff
changeset
|
118 |
(proc: nil; flags: 0), // amDrillStrike |
7078
a3408d9ba5ad
AI can't use cWindSpeedf since it now does a smooth transition
nemo
parents:
7041
diff
changeset
|
119 |
(proc: nil; flags: 0), // amSnowball |
4883
7cddc9201a1d
added dummy for tardis and ugly icons for tardis and structure
Henek
parents:
4881
diff
changeset
|
120 |
(proc: nil; flags: 0), // amTardis |
8161 | 121 |
//(proc: nil; flags: 0), // amStructure |
7007 | 122 |
(proc: nil; flags: 0), // amLandGun |
7730
2013733f9ca9
A bit more on the knife. Also add missing files to CMakeLists
nemo
parents:
7721
diff
changeset
|
123 |
(proc: nil; flags: 0), // amIceGun |
9768
08799c901a42
Add rubber utility. Graphics are still incomplete. Also flag snow/ice in theme config.
nemo
parents:
9722
diff
changeset
|
124 |
(proc: nil; flags: 0), // amKnife |
08799c901a42
Add rubber utility. Graphics are still incomplete. Also flag snow/ice in theme config.
nemo
parents:
9722
diff
changeset
|
125 |
(proc: nil; flags: 0) // amGirder |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
126 |
); |
4 | 127 |
|
128 |
implementation |
|
8959 | 129 |
uses uVariables, uUtils, uGearsHandlers; |
370
c75410fe3133
- Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents:
369
diff
changeset
|
130 |
|
5150
63ad8a648afd
Allow head of rope to attach to hogs/barrels/crates again. Rope still does not, to avoid the bug.
nemo
parents:
5024
diff
changeset
|
131 |
function Metric(x1, y1, x2, y2: LongInt): LongInt; inline; |
4 | 132 |
begin |
370
c75410fe3133
- Repair bots: they can walk and use bazooka, possible cannot jump (why?)
unc0rr
parents:
369
diff
changeset
|
133 |
Metric:= abs(x1 - x2) + abs(y1 - y2) |
4 | 134 |
end; |
135 |
||
8959 | 136 |
function TestBazooka(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
5151
cbadb9fa52fc
An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster.
nemo
parents:
5150
diff
changeset
|
137 |
var Vx, Vy, r, mX, mY: real; |
498 | 138 |
rTime: LongInt; |
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
139 |
EX, EY: LongInt; |
2695 | 140 |
valueResult: LongInt; |
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
141 |
x, y, dX, dY: real; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
142 |
t: LongInt; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
143 |
value: LongInt; |
4 | 144 |
begin |
5151
cbadb9fa52fc
An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster.
nemo
parents:
5150
diff
changeset
|
145 |
mX:= hwFloat2Float(Me^.X); |
cbadb9fa52fc
An experiment - make bazooka AI use float instead of hwFloat - should be as accurate, but faster.
nemo
parents:
5150
diff
changeset
|
146 |
mY:= hwFloat2Float(Me^.Y); |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
147 |
ap.Time:= 0; |
375 | 148 |
rTime:= 350; |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
149 |
ap.ExplR:= 0; |
2695 | 150 |
valueResult:= BadTurn; |
4 | 151 |
repeat |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
152 |
rTime:= rTime + 300 + Level * 50 + random(300); |
8959 | 153 |
Vx:= - windSpeed * rTime * 0.5 + (Targ.Point.X + AIrndSign(2) - mX) / rTime; |
154 |
Vy:= cGravityf * rTime * 0.5 - (Targ.Point.Y + 1 - mY) / rTime; |
|
6775 | 155 |
r:= sqr(Vx) + sqr(Vy); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
156 |
if not (r > 1) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
157 |
begin |
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
158 |
x:= mX; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
159 |
y:= mY; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
160 |
dX:= Vx; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
161 |
dY:= -Vy; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
162 |
t:= rTime; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
163 |
repeat |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
164 |
x:= x + dX; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
165 |
y:= y + dY; |
7078
a3408d9ba5ad
AI can't use cWindSpeedf since it now does a smooth transition
nemo
parents:
7041
diff
changeset
|
166 |
dX:= dX + windSpeed; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
167 |
dY:= dY + cGravityf; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
168 |
dec(t) |
8924 | 169 |
until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or |
8895 | 170 |
((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 5))) or (t <= 0); |
8924 | 171 |
|
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
172 |
EX:= trunc(x); |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
173 |
EY:= trunc(y); |
7471 | 174 |
if Level = 1 then |
7161
21a9c70b2070
Name the flags for fall tracking and indicating whether the explosion erases terrain.
nemo
parents:
7154
diff
changeset
|
175 |
value:= RateExplosion(Me, EX, EY, 101, afTrackFall or afErasesLand) |
6767
ccbf07b38a43
First pass at making AI drowning aware. No concerns of performance, only applied to bazooka (not bat/fp etc)
nemo
parents:
6700
diff
changeset
|
176 |
else value:= RateExplosion(Me, EX, EY, 101); |
8998
d38fb4158342
trying to prevent the AI from attacking barrels. feedback on this welcome.
nemo
parents:
8974
diff
changeset
|
177 |
if (value = 0) and (Targ.Kind = gtHedgehog) and (Targ.Score > 0) then |
8959 | 178 |
value:= 1024 - Metric(Targ.Point.X, Targ.Point.Y, EX, EY) div 64; |
6775 | 179 |
if valueResult <= value then |
180 |
begin |
|
6894 | 181 |
ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random((Level - 1) * 9)); |
6775 | 182 |
ap.Power:= trunc(sqrt(r) * cMaxPower) - random((Level - 1) * 17 + 1); |
183 |
ap.ExplR:= 100; |
|
184 |
ap.ExplX:= EX; |
|
185 |
ap.ExplY:= EY; |
|
186 |
valueResult:= value |
|
187 |
end; |
|
188 |
end |
|
6772 | 189 |
//until (value > 204800) or (rTime > 4250); not so useful since adding score to the drowning |
8903 | 190 |
until rTime > 5050 - Level * 800; |
2695 | 191 |
TestBazooka:= valueResult |
39 | 192 |
end; |
374 | 193 |
|
8033
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
194 |
|
8959 | 195 |
function TestDrillRocket(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
8033
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
196 |
var Vx, Vy, r, mX, mY: real; |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
197 |
rTime: LongInt; |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
198 |
EX, EY: LongInt; |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
199 |
valueResult: LongInt; |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
200 |
x, y, dX, dY: real; |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
201 |
t: LongInt; |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
202 |
value: LongInt; |
8777
cce79a042cfc
merge. hate the fact that "unsynced remote changes" is just a "note" now.
nemo
parents:
8751
diff
changeset
|
203 |
t2: real; |
cce79a042cfc
merge. hate the fact that "unsynced remote changes" is just a "note" now.
nemo
parents:
8751
diff
changeset
|
204 |
timer: Longint; |
8033
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
205 |
begin |
8822
fc9877ff7f1a
Don't reward digging close w/ drill rocket. Doesn't offer much benefit. Reduce final bonus slightly to avoid using drill like bazooka. Better would be AI doing this for all weps based on count. Make main drill loop a little more efficient.
nemo
parents:
8777
diff
changeset
|
206 |
if (Level > 3) then exit(BadTurn); |
fc9877ff7f1a
Don't reward digging close w/ drill rocket. Doesn't offer much benefit. Reduce final bonus slightly to avoid using drill like bazooka. Better would be AI doing this for all weps based on count. Make main drill loop a little more efficient.
nemo
parents:
8777
diff
changeset
|
207 |
|
8033
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
208 |
mX:= hwFloat2Float(Me^.X); |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
209 |
mY:= hwFloat2Float(Me^.Y); |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
210 |
ap.Time:= 0; |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
211 |
rTime:= 350; |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
212 |
ap.ExplR:= 0; |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
213 |
valueResult:= BadTurn; |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
214 |
repeat |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
215 |
rTime:= rTime + 300 + Level * 50 + random(300); |
8959 | 216 |
Vx:= - windSpeed * rTime * 0.5 + (Targ.Point.X + AIrndSign(2) - mX) / rTime; |
217 |
Vy:= cGravityf * rTime * 0.5 - (Targ.Point.Y - 35 - mY) / rTime; |
|
8033
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
218 |
r:= sqr(Vx) + sqr(Vy); |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
219 |
if not (r > 1) then |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
220 |
begin |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
221 |
x:= mX; |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
222 |
y:= mY; |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
223 |
dX:= Vx; |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
224 |
dY:= -Vy; |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
225 |
t:= rTime; |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
226 |
repeat |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
227 |
x:= x + dX; |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
228 |
y:= y + dY; |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
229 |
dX:= dX + windSpeed; |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
230 |
dY:= dY + cGravityf; |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
231 |
dec(t) |
8924 | 232 |
until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or |
8895 | 233 |
((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 5))) or (y > cWaterLine); |
8777
cce79a042cfc
merge. hate the fact that "unsynced remote changes" is just a "note" now.
nemo
parents:
8751
diff
changeset
|
234 |
|
8959 | 235 |
if TestCollExcludingObjects(trunc(x), trunc(y), 5) and (Abs(Targ.Point.X - trunc(x)) + Abs(Targ.Point.Y - trunc(y)) > 21) then |
8777
cce79a042cfc
merge. hate the fact that "unsynced remote changes" is just a "note" now.
nemo
parents:
8751
diff
changeset
|
236 |
begin |
cce79a042cfc
merge. hate the fact that "unsynced remote changes" is just a "note" now.
nemo
parents:
8751
diff
changeset
|
237 |
timer := 500; |
cce79a042cfc
merge. hate the fact that "unsynced remote changes" is just a "note" now.
nemo
parents:
8751
diff
changeset
|
238 |
t2 := 0.5 / sqrt(sqr(dX) + sqr(dY)); |
cce79a042cfc
merge. hate the fact that "unsynced remote changes" is just a "note" now.
nemo
parents:
8751
diff
changeset
|
239 |
dX := dX * t2; |
cce79a042cfc
merge. hate the fact that "unsynced remote changes" is just a "note" now.
nemo
parents:
8751
diff
changeset
|
240 |
dY := dY * t2; |
cce79a042cfc
merge. hate the fact that "unsynced remote changes" is just a "note" now.
nemo
parents:
8751
diff
changeset
|
241 |
repeat |
cce79a042cfc
merge. hate the fact that "unsynced remote changes" is just a "note" now.
nemo
parents:
8751
diff
changeset
|
242 |
x:= x + dX; |
cce79a042cfc
merge. hate the fact that "unsynced remote changes" is just a "note" now.
nemo
parents:
8751
diff
changeset
|
243 |
y:= y + dY; |
cce79a042cfc
merge. hate the fact that "unsynced remote changes" is just a "note" now.
nemo
parents:
8751
diff
changeset
|
244 |
dec(timer); |
8959 | 245 |
until (Abs(Targ.Point.X - trunc(x)) + Abs(Targ.Point.Y - trunc(y)) < 22) |
8777
cce79a042cfc
merge. hate the fact that "unsynced remote changes" is just a "note" now.
nemo
parents:
8751
diff
changeset
|
246 |
or (x < 0) |
cce79a042cfc
merge. hate the fact that "unsynced remote changes" is just a "note" now.
nemo
parents:
8751
diff
changeset
|
247 |
or (y < 0) |
cce79a042cfc
merge. hate the fact that "unsynced remote changes" is just a "note" now.
nemo
parents:
8751
diff
changeset
|
248 |
or (trunc(x) > LAND_WIDTH) |
cce79a042cfc
merge. hate the fact that "unsynced remote changes" is just a "note" now.
nemo
parents:
8751
diff
changeset
|
249 |
or (trunc(y) > LAND_HEIGHT) |
9136 | 250 |
or (not TestCollExcludingObjects(trunc(x), trunc(y), 5)) |
8777
cce79a042cfc
merge. hate the fact that "unsynced remote changes" is just a "note" now.
nemo
parents:
8751
diff
changeset
|
251 |
or (timer = 0) |
cce79a042cfc
merge. hate the fact that "unsynced remote changes" is just a "note" now.
nemo
parents:
8751
diff
changeset
|
252 |
end; |
8033
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
253 |
EX:= trunc(x); |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
254 |
EY:= trunc(y); |
8862 | 255 |
// Try to prevent AI from thinking firing into water will cause a drowning |
8959 | 256 |
if (EY < cWaterLine-5) and (Timer > 0) and (Abs(Targ.Point.X - trunc(x)) + Abs(Targ.Point.Y - trunc(y)) > 21) then exit(BadTurn); |
8033
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
257 |
if Level = 1 then |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
258 |
value:= RateExplosion(Me, EX, EY, 101, afTrackFall or afErasesLand) |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
259 |
else value:= RateExplosion(Me, EX, EY, 101); |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
260 |
if valueResult <= value then |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
261 |
begin |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
262 |
ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random((Level - 1) * 9)); |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
263 |
ap.Power:= trunc(sqrt(r) * cMaxPower) - random((Level - 1) * 17 + 1); |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
264 |
ap.ExplR:= 100; |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
265 |
ap.ExplX:= EX; |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
266 |
ap.ExplY:= EY; |
8824
fe9eacd390f2
Unbreak lua localisation, fix untranslated login prompt, update translations.
nemo
parents:
8822
diff
changeset
|
267 |
valueResult:= value-2500 // trying to make it slightly less attractive than a bazooka, to prevent waste. AI could use awareness of weapon count |
8033
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
268 |
end; |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
269 |
end |
8903 | 270 |
until rTime > 5050 - Level * 800; |
8033
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
271 |
TestDrillRocket:= valueResult |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
272 |
end; |
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
273 |
|
4e40503e2b2c
Pretend AI knows how to use drill rocket (actually has no idea of drilling)
unc0rr
parents:
8013
diff
changeset
|
274 |
|
8959 | 275 |
function TestSnowball(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
6775 | 276 |
var Vx, Vy, r: real; |
4580 | 277 |
rTime: LongInt; |
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
278 |
EX, EY: LongInt; |
4580 | 279 |
valueResult: LongInt; |
6775 | 280 |
x, y, dX, dY, meX, meY: real; |
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
281 |
t: LongInt; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
282 |
value: LongInt; |
4580 | 283 |
|
284 |
begin |
|
6775 | 285 |
meX:= hwFloat2Float(Me^.X); |
286 |
meY:= hwFloat2Float(Me^.Y); |
|
4580 | 287 |
ap.Time:= 0; |
288 |
rTime:= 350; |
|
289 |
ap.ExplR:= 0; |
|
290 |
valueResult:= BadTurn; |
|
291 |
repeat |
|
6775 | 292 |
rTime:= rTime + 300 + Level * 50 + random(1000); |
8959 | 293 |
Vx:= - windSpeed * rTime * 0.5 + ((Targ.Point.X + AIrndSign(2)) - meX) / rTime; |
294 |
Vy:= cGravityf * rTime * 0.5 - (Targ.Point.Y - meY) / rTime; |
|
6775 | 295 |
r:= sqr(Vx) + sqr(Vy); |
296 |
if not (r > 1) then |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
297 |
begin |
6775 | 298 |
x:= meX; |
299 |
y:= meY; |
|
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
300 |
dX:= Vx; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
301 |
dY:= -Vy; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
302 |
t:= rTime; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
303 |
repeat |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
304 |
x:= x + dX; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
305 |
y:= y + dY; |
7078
a3408d9ba5ad
AI can't use cWindSpeedf since it now does a smooth transition
nemo
parents:
7041
diff
changeset
|
306 |
dX:= dX + windSpeed; |
6775 | 307 |
dY:= dY + cGravityf; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
308 |
dec(t) |
8924 | 309 |
until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or |
8895 | 310 |
((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 5))) or (t <= 0); |
6775 | 311 |
EX:= trunc(x); |
312 |
EY:= trunc(y); |
|
313 |
||
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8924
diff
changeset
|
314 |
value:= RateShove(Me, trunc(x), trunc(y), 5, 1, trunc((abs(dX)+abs(dY))*20), -dX, -dY, afTrackFall); |
8013 | 315 |
// LOL copypasta: this is score for digging with... snowball |
316 |
//if value = 0 then |
|
8959 | 317 |
// value:= - Metric(Targ.Point.X, Targ.Point.Y, EX, EY) div 64; |
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
318 |
|
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
319 |
if valueResult <= value then |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
320 |
begin |
6894 | 321 |
ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random((Level - 1) * 9)); |
6775 | 322 |
ap.Power:= trunc(sqrt(r) * cMaxPower) - random((Level - 1) * 17 + 1); |
323 |
ap.ExplR:= 0; |
|
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
324 |
ap.ExplX:= EX; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
325 |
ap.ExplY:= EY; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
326 |
valueResult:= value |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
327 |
end; |
4580 | 328 |
end |
8903 | 329 |
until (rTime > 5050 - Level * 800); |
4580 | 330 |
TestSnowball:= valueResult |
331 |
end; |
|
332 |
||
8959 | 333 |
function TestMolotov(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
6775 | 334 |
var Vx, Vy, r: real; |
3018
13ceaad4767e
Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking.
nemo
parents:
2978
diff
changeset
|
335 |
Score, EX, EY, valueResult: LongInt; |
9145 | 336 |
TestTime: LongInt; |
6775 | 337 |
x, y, dY, meX, meY: real; |
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
338 |
t: LongInt; |
3018
13ceaad4767e
Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking.
nemo
parents:
2978
diff
changeset
|
339 |
begin |
6775 | 340 |
meX:= hwFloat2Float(Me^.X); |
341 |
meY:= hwFloat2Float(Me^.Y); |
|
3018
13ceaad4767e
Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking.
nemo
parents:
2978
diff
changeset
|
342 |
valueResult:= BadTurn; |
13ceaad4767e
Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking.
nemo
parents:
2978
diff
changeset
|
343 |
TestTime:= 0; |
13ceaad4767e
Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking.
nemo
parents:
2978
diff
changeset
|
344 |
ap.ExplR:= 0; |
13ceaad4767e
Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking.
nemo
parents:
2978
diff
changeset
|
345 |
repeat |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
346 |
inc(TestTime, 300); |
8959 | 347 |
Vx:= (Targ.Point.X - meX) / TestTime; |
348 |
Vy:= cGravityf * (TestTime div 2) - Targ.Point.Y - meY / TestTime; |
|
6775 | 349 |
r:= sqr(Vx) + sqr(Vy); |
350 |
if not (r > 1) then |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
351 |
begin |
6775 | 352 |
x:= meX; |
353 |
y:= meY; |
|
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
354 |
dY:= -Vy; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
355 |
t:= TestTime; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
356 |
repeat |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
357 |
x:= x + Vx; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
358 |
y:= y + dY; |
6775 | 359 |
dY:= dY + cGravityf; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
360 |
dec(t) |
8924 | 361 |
until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 6)) or |
8895 | 362 |
((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 6))) or (t = 0); |
6775 | 363 |
EX:= trunc(x); |
364 |
EY:= trunc(y); |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
365 |
if t < 50 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
366 |
Score:= RateExplosion(Me, EX, EY, 97) // average of 17 attempts, most good, but some failing spectacularly |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
367 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
368 |
Score:= BadTurn; |
8924 | 369 |
|
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
370 |
if valueResult < Score then |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
371 |
begin |
6894 | 372 |
ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level)); |
6775 | 373 |
ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15); |
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
374 |
ap.ExplR:= 100; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
375 |
ap.ExplX:= EX; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
376 |
ap.ExplY:= EY; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
377 |
valueResult:= Score |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
378 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
379 |
end |
8903 | 380 |
until (TestTime > 5050 - Level * 800); |
3018
13ceaad4767e
Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking.
nemo
parents:
2978
diff
changeset
|
381 |
TestMolotov:= valueResult |
13ceaad4767e
Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking.
nemo
parents:
2978
diff
changeset
|
382 |
end; |
13ceaad4767e
Adjust tests for cluster and watermelon, add molotov, assign FP test to whip, try to keep AI from attempting fire walking.
nemo
parents:
2978
diff
changeset
|
383 |
|
8959 | 384 |
function TestGrenade(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
70 | 385 |
const tDelta = 24; |
6775 | 386 |
var Vx, Vy, r: real; |
2695 | 387 |
Score, EX, EY, valueResult: LongInt; |
9145 | 388 |
TestTime: LongInt; |
6775 | 389 |
x, y, meX, meY, dY: real; |
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
390 |
t: LongInt; |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
391 |
begin |
2695 | 392 |
valueResult:= BadTurn; |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
393 |
TestTime:= 0; |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
394 |
ap.ExplR:= 0; |
6775 | 395 |
meX:= hwFloat2Float(Me^.X); |
396 |
meY:= hwFloat2Float(Me^.Y); |
|
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
397 |
repeat |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
398 |
inc(TestTime, 1000); |
8959 | 399 |
Vx:= (Targ.Point.X - meX) / (TestTime + tDelta); |
400 |
Vy:= cGravityf * ((TestTime + tDelta) div 2) - (Targ.Point.Y - meY) / (TestTime + tDelta); |
|
6775 | 401 |
r:= sqr(Vx) + sqr(Vy); |
402 |
if not (r > 1) then |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
403 |
begin |
6775 | 404 |
x:= meX; |
8924 | 405 |
y:= meY; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
406 |
dY:= -Vy; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
407 |
t:= TestTime; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
408 |
repeat |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
409 |
x:= x + Vx; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
410 |
y:= y + dY; |
6775 | 411 |
dY:= dY + cGravityf; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
412 |
dec(t) |
8924 | 413 |
until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or |
8895 | 414 |
((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 5))) or (t = 0); |
6775 | 415 |
EX:= trunc(x); |
416 |
EY:= trunc(y); |
|
8924 | 417 |
if t < 50 then |
7471 | 418 |
if Level = 1 then |
7161
21a9c70b2070
Name the flags for fall tracking and indicating whether the explosion erases terrain.
nemo
parents:
7154
diff
changeset
|
419 |
Score:= RateExplosion(Me, EX, EY, 101, afTrackFall or afErasesLand) |
6769
44ad49a3a126
Add drowning to grenade too, try some little optimisations
nemo
parents:
6767
diff
changeset
|
420 |
else Score:= RateExplosion(Me, EX, EY, 101) |
8924 | 421 |
else |
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
422 |
Score:= BadTurn; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
423 |
|
8013 | 424 |
if (valueResult < Score) and (Score > 0) then |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
425 |
begin |
8903 | 426 |
ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level * 3)); |
427 |
ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 20); |
|
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
428 |
ap.Time:= TestTime; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
429 |
ap.ExplR:= 100; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
430 |
ap.ExplX:= EX; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
431 |
ap.ExplY:= EY; |
2695 | 432 |
valueResult:= Score |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
433 |
end; |
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
434 |
end |
6772 | 435 |
//until (Score > 204800) or (TestTime > 4000); |
8903 | 436 |
until TestTime > 4500 - Level * 512; |
2695 | 437 |
TestGrenade:= valueResult |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
438 |
end; |
375 | 439 |
|
8959 | 440 |
function TestClusterBomb(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
2978 | 441 |
const tDelta = 24; |
6775 | 442 |
var Vx, Vy, r: real; |
2978 | 443 |
Score, EX, EY, valueResult: LongInt; |
444 |
TestTime: Longword; |
|
6775 | 445 |
x, y, dY, meX, meY: real; |
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
446 |
t: LongInt; |
2978 | 447 |
begin |
448 |
valueResult:= BadTurn; |
|
7441 | 449 |
TestTime:= 500; |
2978 | 450 |
ap.ExplR:= 0; |
6775 | 451 |
meX:= hwFloat2Float(Me^.X); |
452 |
meY:= hwFloat2Float(Me^.Y); |
|
2978 | 453 |
repeat |
7441 | 454 |
inc(TestTime, 900); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
455 |
// Try to overshoot slightly, seems to pay slightly better dividends in terms of hitting cluster |
8959 | 456 |
if meX<Targ.Point.X then |
457 |
Vx:= ((Targ.Point.X+10) - meX) / (TestTime + tDelta) |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
458 |
else |
8959 | 459 |
Vx:= ((Targ.Point.X-10) - meX) / (TestTime + tDelta); |
460 |
Vy:= cGravityf * ((TestTime + tDelta) div 2) - ((Targ.Point.Y-50) - meY) / (TestTime + tDelta); |
|
6775 | 461 |
r:= sqr(Vx)+sqr(Vy); |
462 |
if not (r > 1) then |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
463 |
begin |
6775 | 464 |
x:= meX; |
465 |
y:= meY; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
466 |
dY:= -Vy; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
467 |
t:= TestTime; |
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
468 |
repeat |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
469 |
x:= x + Vx; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
470 |
y:= y + dY; |
6775 | 471 |
dY:= dY + cGravityf; |
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
472 |
dec(t) |
8924 | 473 |
until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 5)) or |
8895 | 474 |
((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 5))) or (t = 0); |
6775 | 475 |
EX:= trunc(x); |
476 |
EY:= trunc(y); |
|
8924 | 477 |
if t < 50 then |
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
478 |
Score:= RateExplosion(Me, EX, EY, 41) |
8924 | 479 |
else |
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
480 |
Score:= BadTurn; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
481 |
|
8974
d360e97ce842
I don't see how rating these against others is useful, given the limited radius, and the cluster bomb thing just seems counterproductive. Anyway, this prevents AI from picking on barrels.
nemo
parents:
8971
diff
changeset
|
482 |
if Score > 0 then |
2978 | 483 |
begin |
8903 | 484 |
ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level * 2)); |
7132 | 485 |
ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15); |
7441 | 486 |
ap.Time:= TestTime div 1000 * 1000; |
2978 | 487 |
ap.ExplR:= 90; |
488 |
ap.ExplX:= EX; |
|
489 |
ap.ExplY:= EY; |
|
490 |
valueResult:= Score |
|
491 |
end; |
|
492 |
end |
|
7441 | 493 |
until (TestTime = 4100); |
2978 | 494 |
TestClusterBomb:= valueResult |
495 |
end; |
|
496 |
||
8959 | 497 |
function TestWatermelon(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
2973
b51a0f57cd43
Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents:
2948
diff
changeset
|
498 |
const tDelta = 24; |
6775 | 499 |
var Vx, Vy, r: real; |
2973
b51a0f57cd43
Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents:
2948
diff
changeset
|
500 |
Score, EX, EY, valueResult: LongInt; |
b51a0f57cd43
Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents:
2948
diff
changeset
|
501 |
TestTime: Longword; |
6775 | 502 |
x, y, dY, meX, meY: real; |
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
503 |
t: LongInt; |
2973
b51a0f57cd43
Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents:
2948
diff
changeset
|
504 |
begin |
b51a0f57cd43
Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents:
2948
diff
changeset
|
505 |
valueResult:= BadTurn; |
7441 | 506 |
TestTime:= 500; |
2973
b51a0f57cd43
Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents:
2948
diff
changeset
|
507 |
ap.ExplR:= 0; |
6775 | 508 |
meX:= hwFloat2Float(Me^.X); |
509 |
meY:= hwFloat2Float(Me^.Y); |
|
2973
b51a0f57cd43
Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents:
2948
diff
changeset
|
510 |
repeat |
7441 | 511 |
inc(TestTime, 900); |
8959 | 512 |
Vx:= (Targ.Point.X - meX) / (TestTime + tDelta); |
513 |
Vy:= cGravityf * ((TestTime + tDelta) div 2) - ((Targ.Point.Y-50) - meY) / (TestTime + tDelta); |
|
6775 | 514 |
r:= sqr(Vx)+sqr(Vy); |
515 |
if not (r > 1) then |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
516 |
begin |
6775 | 517 |
x:= meX; |
518 |
y:= meY; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
519 |
dY:= -Vy; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
520 |
t:= TestTime; |
7132 | 521 |
repeat |
522 |
x:= x + Vx; |
|
523 |
y:= y + dY; |
|
524 |
dY:= dY + cGravityf; |
|
525 |
dec(t) |
|
8924 | 526 |
until (((Me = CurrentHedgehog^.Gear) and TestColl(trunc(x), trunc(y), 6)) or |
8895 | 527 |
((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, trunc(x), trunc(y), 6))) or (t = 0); |
8924 | 528 |
|
7132 | 529 |
EX:= trunc(x); |
530 |
EY:= trunc(y); |
|
8924 | 531 |
if t < 50 then |
7132 | 532 |
Score:= RateExplosion(Me, EX, EY, 200) + RateExplosion(Me, EX, EY + 120, 200) |
8924 | 533 |
else |
7132 | 534 |
Score:= BadTurn; |
8924 | 535 |
|
7132 | 536 |
if valueResult < Score then |
537 |
begin |
|
538 |
ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level)); |
|
539 |
ap.Power:= trunc(sqrt(r) * cMaxPower) + AIrndSign(random(Level) * 15); |
|
7441 | 540 |
ap.Time:= TestTime div 1000 * 1000; |
7132 | 541 |
ap.ExplR:= 300; |
542 |
ap.ExplX:= EX; |
|
543 |
ap.ExplY:= EY; |
|
544 |
valueResult:= Score |
|
545 |
end; |
|
546 |
end |
|
7441 | 547 |
until (TestTime = 4100); |
2973
b51a0f57cd43
Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents:
2948
diff
changeset
|
548 |
TestWatermelon:= valueResult |
b51a0f57cd43
Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents:
2948
diff
changeset
|
549 |
end; |
b51a0f57cd43
Crude copy of grenade routine to allow AI to use watermelon bomb with reasonable lethalness.
nemo
parents:
2948
diff
changeset
|
550 |
|
994 | 551 |
|
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
552 |
function Solve(TX, TY, MX, MY: LongInt): LongWord; |
6775 | 553 |
var A, B, D, T: real; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
554 |
C: LongInt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
555 |
begin |
7132 | 556 |
A:= sqr(cGravityf); |
6775 | 557 |
B:= - cGravityf * (TY - MY) - 1; |
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
558 |
C:= sqr(TY - MY) + sqr(TX - MX); |
7132 | 559 |
D:= sqr(B) - A * C; |
6775 | 560 |
if D >= 0 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
561 |
begin |
7132 | 562 |
D:= sqrt(D) - B; |
6775 | 563 |
if D >= 0 then |
7132 | 564 |
T:= sqrt(D * 2 / A) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
565 |
else |
6775 | 566 |
T:= 0; |
567 |
Solve:= trunc(T) |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
568 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
569 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
570 |
Solve:= 0 |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
571 |
end; |
8924 | 572 |
|
8959 | 573 |
function TestMortar(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
574 |
//const tDelta = 24; |
6775 | 575 |
var Vx, Vy: real; |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6894
diff
changeset
|
576 |
Score, EX, EY: LongInt; |
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
577 |
TestTime: Longword; |
6775 | 578 |
x, y, dY, meX, meY: real; |
994 | 579 |
begin |
7041 | 580 |
TestMortar:= BadTurn; |
581 |
ap.ExplR:= 0; |
|
7790 | 582 |
|
7041 | 583 |
meX:= hwFloat2Float(Me^.X); |
584 |
meY:= hwFloat2Float(Me^.Y); |
|
994 | 585 |
|
7041 | 586 |
if (Level > 2) then |
587 |
exit(BadTurn); |
|
994 | 588 |
|
8959 | 589 |
TestTime:= Solve(Targ.Point.X, Targ.Point.Y, trunc(meX), trunc(meY)); |
994 | 590 |
|
7041 | 591 |
if TestTime = 0 then |
592 |
exit(BadTurn); |
|
994 | 593 |
|
8959 | 594 |
Vx:= (Targ.Point.X - meX) / TestTime; |
595 |
Vy:= cGravityf * (TestTime div 2) - (Targ.Point.Y - meY) / TestTime; |
|
994 | 596 |
|
6775 | 597 |
x:= meX; |
598 |
y:= meY; |
|
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
599 |
dY:= -Vy; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
600 |
|
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
601 |
repeat |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
602 |
x:= x + Vx; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
603 |
y:= y + dY; |
6775 | 604 |
dY:= dY + cGravityf; |
605 |
EX:= trunc(x); |
|
606 |
EY:= trunc(y); |
|
8924 | 607 |
until (((Me = CurrentHedgehog^.Gear) and TestColl(EX, EY, 4)) or |
8895 | 608 |
((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, EX, EY, 4))) or (EY > cWaterLine); |
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
609 |
|
6775 | 610 |
if (EY < cWaterLine) and (dY >= 0) then |
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
611 |
begin |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
612 |
Score:= RateExplosion(Me, EX, EY, 91); |
9005 | 613 |
if (Score = 0) then |
614 |
if (dY > 0.15) and (Targ.Kind = gtHedgehog) and (Targ.Score > 0) then |
|
8959 | 615 |
Score:= - abs(Targ.Point.Y - EY) div 32 |
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
616 |
else |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
617 |
Score:= BadTurn |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
618 |
else if (Score < 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
619 |
Score:= BadTurn |
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
620 |
end |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
621 |
else |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
622 |
Score:= BadTurn; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6453
diff
changeset
|
623 |
|
8998
d38fb4158342
trying to prevent the AI from attacking barrels. feedback on this welcome.
nemo
parents:
8974
diff
changeset
|
624 |
if Score > 0 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
625 |
begin |
6894 | 626 |
ap.Angle:= DxDy2AttackAnglef(Vx, Vy) + AIrndSign(random(Level)); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
627 |
ap.Power:= 1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
628 |
ap.ExplR:= 100; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
629 |
ap.ExplX:= EX; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
630 |
ap.ExplY:= EY; |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6894
diff
changeset
|
631 |
TestMortar:= Score |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2695
diff
changeset
|
632 |
end; |
994 | 633 |
end; |
634 |
||
8959 | 635 |
function TestShotgun(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
1941 | 636 |
const |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
637 |
MIN_RANGE = 80; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
638 |
MAX_RANGE = 400; |
6775 | 639 |
var Vx, Vy, x, y: real; |
2695 | 640 |
rx, ry, valueResult: LongInt; |
1941 | 641 |
range: integer; |
375 | 642 |
begin |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6894
diff
changeset
|
643 |
TestShotgun:= BadTurn; |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
644 |
ap.ExplR:= 0; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
645 |
ap.Time:= 0; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
646 |
ap.Power:= 1; |
6775 | 647 |
x:= hwFloat2Float(Me^.X); |
648 |
y:= hwFloat2Float(Me^.Y); |
|
8959 | 649 |
range:= Metric(trunc(x), trunc(y), Targ.Point.X, Targ.Point.Y); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
650 |
if ( range < MIN_RANGE ) or ( range > MAX_RANGE ) then |
7041 | 651 |
exit(BadTurn); |
652 |
||
8959 | 653 |
Vx:= (Targ.Point.X - x) * 1 / 1024; |
654 |
Vy:= (Targ.Point.Y - y) * 1 / 1024; |
|
6894 | 655 |
ap.Angle:= DxDy2AttackAnglef(Vx, -Vy); |
70 | 656 |
repeat |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
657 |
x:= x + vX; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
658 |
y:= y + vY; |
6775 | 659 |
rx:= trunc(x); |
660 |
ry:= trunc(y); |
|
8924 | 661 |
if ((Me = CurrentHedgehog^.Gear) and TestColl(rx, ry, 2)) or |
8895 | 662 |
((Me <> CurrentHedgehog^.Gear) and TestCollExcludingMe(Me^.Hedgehog^.Gear, rx, ry, 2)) then |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6894
diff
changeset
|
663 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
664 |
x:= x + vX * 8; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
665 |
y:= y + vY * 8; |
6775 | 666 |
valueResult:= RateShotgun(Me, vX, vY, rx, ry); |
8924 | 667 |
|
8998
d38fb4158342
trying to prevent the AI from attacking barrels. feedback on this welcome.
nemo
parents:
8974
diff
changeset
|
668 |
if (valueResult = 0) and (Targ.Kind = gtHedgehog) and (Targ.Score > 0) then |
8959 | 669 |
valueResult:= 1024 - Metric(Targ.Point.X, Targ.Point.Y, rx, ry) div 64 |
8924 | 670 |
else |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6894
diff
changeset
|
671 |
dec(valueResult, Level * 4000); |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6894
diff
changeset
|
672 |
// 27/20 is reuse bonus |
7041 | 673 |
exit(valueResult * 27 div 20) |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
674 |
end |
8959 | 675 |
until (Abs(Targ.Point.X - trunc(x)) + Abs(Targ.Point.Y - trunc(y)) < 4) |
6775 | 676 |
or (x < 0) |
677 |
or (y < 0) |
|
678 |
or (trunc(x) > LAND_WIDTH) |
|
679 |
or (trunc(y) > LAND_HEIGHT); |
|
4157 | 680 |
|
375 | 681 |
TestShotgun:= BadTurn |
70 | 682 |
end; |
438 | 683 |
|
8959 | 684 |
function TestDesertEagle(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
8971
fcb29a13b1b1
Adjust barrel damage so AI can actually bat to explode them. Fix state flag check. Remove unneeded dmgMod var. Cancel dX for low dX barrel tracing.
nemo
parents:
8959
diff
changeset
|
685 |
var Vx, Vy, x, y, t: real; |
75 | 686 |
d: Longword; |
10097 | 687 |
ix, iy, valueResult: LongInt; |
75 | 688 |
begin |
8974
d360e97ce842
I don't see how rating these against others is useful, given the limited radius, and the cluster bomb thing just seems counterproductive. Anyway, this prevents AI from picking on barrels.
nemo
parents:
8971
diff
changeset
|
689 |
if (Level > 4) or (Targ.Score < 0) or (Targ.Kind <> gtHedgehog) then exit(BadTurn); |
3407 | 690 |
Level:= Level; // avoid compiler hint |
8952
a6ee1e7310fb
trying to make AI aware of mine/explosive break point. also remove redundant test.
nemo
parents:
8950
diff
changeset
|
691 |
ap.ExplR:= 1; |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
692 |
ap.Time:= 0; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
693 |
ap.Power:= 1; |
7471 | 694 |
|
6775 | 695 |
x:= hwFloat2Float(Me^.X); |
696 |
y:= hwFloat2Float(Me^.Y); |
|
7471 | 697 |
|
8959 | 698 |
if Abs(trunc(x) - Targ.Point.X) + Abs(trunc(y) - Targ.Point.Y) < 20 then |
7041 | 699 |
exit(BadTurn); |
7471 | 700 |
|
8959 | 701 |
t:= 2 / sqrt(sqr(Targ.Point.X - x)+sqr(Targ.Point.Y-y)); |
702 |
Vx:= (Targ.Point.X - x) * t; |
|
703 |
Vy:= (Targ.Point.Y - y) * t; |
|
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
704 |
ap.Angle:= DxDy2AttackAnglef(Vx, -Vy); |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
705 |
d:= 0; |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
706 |
|
10097 | 707 |
ix:= trunc(x); |
708 |
iy:= trunc(y); |
|
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
709 |
|
10097 | 710 |
if ((ix and LAND_WIDTH_MASK) = 0) and ((iy and LAND_HEIGHT_MASK) = 0) then |
711 |
repeat |
|
712 |
if Land[iy, ix] <> 0 then |
|
713 |
inc(d); |
|
714 |
x:= x + vX; |
|
715 |
y:= y + vY; |
|
716 |
ix:= trunc(x); |
|
717 |
iy:= trunc(y); |
|
718 |
until (Abs(Targ.Point.X - ix) + Abs(Targ.Point.Y - iy) < 5) |
|
719 |
or (x < 0) |
|
720 |
or (y < 0) |
|
721 |
or (ix >= LAND_WIDTH) |
|
722 |
or (iy >= LAND_HEIGHT) |
|
723 |
or (d > 48); |
|
724 |
||
725 |
if Abs(Targ.Point.X - ix) + Abs(Targ.Point.Y - iy) < 5 then |
|
9495
2fc346fadae3
- AI quickly shoots with desert eagle till hits the target
unc0rr
parents:
9145
diff
changeset
|
726 |
begin |
2fc346fadae3
- AI quickly shoots with desert eagle till hits the target
unc0rr
parents:
9145
diff
changeset
|
727 |
ap.AttacksNum:= 1 + (d + 8) div 12; |
2fc346fadae3
- AI quickly shoots with desert eagle till hits the target
unc0rr
parents:
9145
diff
changeset
|
728 |
valueResult:= RateShove(Me, Targ.Point.X, Targ.Point.Y, 1, 7, 20, vX*0.125, vY*0.125, afTrackFall) - ap.AttacksNum |
2fc346fadae3
- AI quickly shoots with desert eagle till hits the target
unc0rr
parents:
9145
diff
changeset
|
729 |
end |
2fc346fadae3
- AI quickly shoots with desert eagle till hits the target
unc0rr
parents:
9145
diff
changeset
|
730 |
else |
2fc346fadae3
- AI quickly shoots with desert eagle till hits the target
unc0rr
parents:
9145
diff
changeset
|
731 |
valueResult:= BadTurn; |
2fc346fadae3
- AI quickly shoots with desert eagle till hits the target
unc0rr
parents:
9145
diff
changeset
|
732 |
|
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
733 |
TestDesertEagle:= valueResult |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
734 |
end; |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
735 |
|
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
736 |
|
8959 | 737 |
function TestSniperRifle(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
8971
fcb29a13b1b1
Adjust barrel damage so AI can actually bat to explode them. Fix state flag check. Remove unneeded dmgMod var. Cancel dX for low dX barrel tracing.
nemo
parents:
8959
diff
changeset
|
738 |
var Vx, Vy, x, y, t, dmg: real; |
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
739 |
d: Longword; |
9137
d987230b85ed
fixed all engine compilation hints and notes (that I could see)
sheepluva
parents:
9080
diff
changeset
|
740 |
//fallDmg: LongInt; |
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
741 |
begin |
8974
d360e97ce842
I don't see how rating these against others is useful, given the limited radius, and the cluster bomb thing just seems counterproductive. Anyway, this prevents AI from picking on barrels.
nemo
parents:
8971
diff
changeset
|
742 |
if (Level > 3) or (Targ.Score < 0) or (Targ.Kind <> gtHedgehog) then exit(BadTurn); |
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
743 |
Level:= Level; // avoid compiler hint |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
744 |
ap.ExplR:= 0; |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
745 |
ap.Time:= 0; |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
746 |
ap.Power:= 1; |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
747 |
x:= hwFloat2Float(Me^.X); |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
748 |
y:= hwFloat2Float(Me^.Y); |
8959 | 749 |
if Abs(trunc(x) - Targ.Point.X) + Abs(trunc(y) - Targ.Point.Y) < 40 then |
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
750 |
exit(BadTurn); |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
751 |
|
8959 | 752 |
dmg:= sqrt(sqr(Targ.Point.X - x)+sqr(Targ.Point.Y-y)); |
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
753 |
t:= 1.5 / dmg; |
7208
62e36dc45098
Ignore all objects for fall tracing with shove to avoid considering checkins as obstacles. many objects will get knocked by the kick anyway, so end result should be pretty good. Oh, and ditch the sniper rifle doubling.
nemo
parents:
7206
diff
changeset
|
754 |
dmg:= dmg * 0.025; // div 40 |
8959 | 755 |
Vx:= (Targ.Point.X - x) * t; |
756 |
Vy:= (Targ.Point.Y - y) * t; |
|
6894 | 757 |
ap.Angle:= DxDy2AttackAnglef(Vx, -Vy); |
75 | 758 |
d:= 0; |
1941 | 759 |
|
75 | 760 |
repeat |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
761 |
x:= x + vX; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
762 |
y:= y + vY; |
6775 | 763 |
if ((trunc(x) and LAND_WIDTH_MASK) = 0)and((trunc(y) and LAND_HEIGHT_MASK) = 0) |
764 |
and (Land[trunc(y), trunc(x)] <> 0) then |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
765 |
inc(d); |
8959 | 766 |
until (Abs(Targ.Point.X - trunc(x)) + Abs(Targ.Point.Y - trunc(y)) < 4) |
6775 | 767 |
or (x < 0) |
768 |
or (y < 0) |
|
769 |
or (trunc(x) > LAND_WIDTH) |
|
770 |
or (trunc(y) > LAND_HEIGHT) |
|
7873 | 771 |
or (d > 22); |
1941 | 772 |
|
8959 | 773 |
if Abs(Targ.Point.X - trunc(x)) + Abs(Targ.Point.Y - trunc(y)) < 4 then |
774 |
TestSniperRifle:= RateShove(Me, Targ.Point.X, Targ.Point.Y, 1, trunc(dmg), 20, vX*0.166, vY*0.166, afTrackFall) |
|
8952
a6ee1e7310fb
trying to make AI aware of mine/explosive break point. also remove redundant test.
nemo
parents:
8950
diff
changeset
|
775 |
else TestSniperRifle:= BadTurn; |
75 | 776 |
end; |
438 | 777 |
|
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
778 |
|
8959 | 779 |
function TestBaseballBat(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
7212 | 780 |
var valueResult, a, v1, v2: LongInt; |
7348
2a69f2ed9273
Limit firepunch/whip drowning checks to max AI, bat to top 2 levels.
nemo
parents:
7274
diff
changeset
|
781 |
x, y, trackFall: LongInt; |
7212 | 782 |
dx, dy: real; |
79 | 783 |
begin |
7716 | 784 |
Targ:= Targ; // avoid compiler hint |
785 |
||
7471 | 786 |
if Level < 3 then trackFall:= afTrackFall |
8026
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
8013
diff
changeset
|
787 |
else trackFall:= 0; |
7471 | 788 |
|
7212 | 789 |
ap.ExplR:= 0; |
790 |
ap.Time:= 0; |
|
791 |
ap.Power:= 1; |
|
792 |
x:= hwRound(Me^.X); |
|
793 |
y:= hwRound(Me^.Y); |
|
794 |
||
7424
fe0f07667f24
Prefer to bat enemy away dealing the same amount of damage
unc0rr
parents:
7416
diff
changeset
|
795 |
a:= cMaxAngle div 2; |
7212 | 796 |
valueResult:= 0; |
797 |
||
7424
fe0f07667f24
Prefer to bat enemy away dealing the same amount of damage
unc0rr
parents:
7416
diff
changeset
|
798 |
while a >= 0 do |
7212 | 799 |
begin |
800 |
dx:= sin(a / cMaxAngle * pi) * 0.5; |
|
801 |
dy:= cos(a / cMaxAngle * pi) * 0.5; |
|
433 | 802 |
|
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8924
diff
changeset
|
803 |
v1:= RateShove(Me, x - 10, y + 2 |
7427 | 804 |
, 32, 30, 115 |
7348
2a69f2ed9273
Limit firepunch/whip drowning checks to max AI, bat to top 2 levels.
nemo
parents:
7274
diff
changeset
|
805 |
, -dx, -dy, trackFall); |
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8924
diff
changeset
|
806 |
v2:= RateShove(Me, x + 10, y + 2 |
7427 | 807 |
, 32, 30, 115 |
7348
2a69f2ed9273
Limit firepunch/whip drowning checks to max AI, bat to top 2 levels.
nemo
parents:
7274
diff
changeset
|
808 |
, dx, -dy, trackFall); |
7212 | 809 |
if (v1 > valueResult) or (v2 > valueResult) then |
8924 | 810 |
if (v2 > v1) |
7212 | 811 |
or {don't encourage turning for no gain}((v2 = v1) and (not Me^.dX.isNegative)) then |
812 |
begin |
|
813 |
ap.Angle:= a; |
|
814 |
valueResult:= v2 |
|
815 |
end |
|
8924 | 816 |
else |
7212 | 817 |
begin |
818 |
ap.Angle:= -a; |
|
819 |
valueResult:= v1 |
|
820 |
end; |
|
6770
7d2c6cdb816a
Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents:
6769
diff
changeset
|
821 |
|
7424
fe0f07667f24
Prefer to bat enemy away dealing the same amount of damage
unc0rr
parents:
7416
diff
changeset
|
822 |
a:= a - 15 - random(cMaxAngle div 16) |
7212 | 823 |
end; |
8924 | 824 |
|
7212 | 825 |
if valueResult <= 0 then |
826 |
valueResult:= BadTurn; |
|
827 |
||
828 |
TestBaseballBat:= valueResult; |
|
79 | 829 |
end; |
830 |
||
8959 | 831 |
function TestFirePunch(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
7200
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
832 |
var valueResult, v1, v2, i: LongInt; |
7348
2a69f2ed9273
Limit firepunch/whip drowning checks to max AI, bat to top 2 levels.
nemo
parents:
7274
diff
changeset
|
833 |
x, y, trackFall: LongInt; |
82 | 834 |
begin |
7716 | 835 |
Targ:= Targ; // avoid compiler hint |
836 |
||
7471 | 837 |
if Level = 1 then trackFall:= afTrackFall |
7348
2a69f2ed9273
Limit firepunch/whip drowning checks to max AI, bat to top 2 levels.
nemo
parents:
7274
diff
changeset
|
838 |
else trackFall:= 0; |
7471 | 839 |
|
7200
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
840 |
ap.ExplR:= 0; |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
841 |
ap.Time:= 0; |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
842 |
ap.Power:= 1; |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
843 |
x:= hwRound(Me^.X); |
7427 | 844 |
y:= hwRound(Me^.Y) + 4; |
7200
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
845 |
|
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
846 |
v1:= 0; |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
847 |
for i:= 0 to 8 do |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
848 |
begin |
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8924
diff
changeset
|
849 |
v1:= v1 + RateShove(Me, x - 5, y - 10 * i |
7427 | 850 |
, 19, 30, 40 |
7348
2a69f2ed9273
Limit firepunch/whip drowning checks to max AI, bat to top 2 levels.
nemo
parents:
7274
diff
changeset
|
851 |
, -0.45, -0.9, trackFall or afSetSkip); |
7200
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
852 |
end; |
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8924
diff
changeset
|
853 |
v1:= v1 + RateShove(Me, x - 5, y - 90 |
7427 | 854 |
, 19, 30, 40 |
7348
2a69f2ed9273
Limit firepunch/whip drowning checks to max AI, bat to top 2 levels.
nemo
parents:
7274
diff
changeset
|
855 |
, -0.45, -0.9, trackFall); |
7200
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
856 |
|
433 | 857 |
|
7200
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
858 |
// now try opposite direction |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
859 |
v2:= 0; |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
860 |
for i:= 0 to 8 do |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
861 |
begin |
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8924
diff
changeset
|
862 |
v2:= v2 + RateShove(Me, x + 5, y - 10 * i |
7427 | 863 |
, 19, 30, 40 |
7348
2a69f2ed9273
Limit firepunch/whip drowning checks to max AI, bat to top 2 levels.
nemo
parents:
7274
diff
changeset
|
864 |
, 0.45, -0.9, trackFall or afSetSkip); |
7200
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
865 |
end; |
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8924
diff
changeset
|
866 |
v2:= v2 + RateShove(Me, x + 5, y - 90 |
7427 | 867 |
, 19, 30, 40 |
7348
2a69f2ed9273
Limit firepunch/whip drowning checks to max AI, bat to top 2 levels.
nemo
parents:
7274
diff
changeset
|
868 |
, 0.45, -0.9, trackFall); |
7200
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
869 |
|
8924 | 870 |
if (v2 > v1) |
7200
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
871 |
or {don't encourage turning for no gain}((v2 = v1) and (not Me^.dX.isNegative)) then |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
872 |
begin |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
873 |
ap.Angle:= 1; |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
874 |
valueResult:= v2 |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
875 |
end |
8924 | 876 |
else |
7200
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
877 |
begin |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
878 |
ap.Angle:= -1; |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
879 |
valueResult:= v1 |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
880 |
end; |
8924 | 881 |
|
7200
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
882 |
if valueResult <= 0 then |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
883 |
valueResult:= BadTurn; |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
884 |
|
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
885 |
TestFirePunch:= valueResult; |
82 | 886 |
end; |
433 | 887 |
|
7178
c61cfc9eb29d
Don't make unnecessary calls to TestWhip, TestFirePunch, TestBaseballBat and TestHammer functions as they have no need to take Targ parameter into account and thus may only be called once per position
unc0rr
parents:
7161
diff
changeset
|
888 |
|
8959 | 889 |
function TestWhip(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
7154 | 890 |
var valueResult, v1, v2: LongInt; |
7348
2a69f2ed9273
Limit firepunch/whip drowning checks to max AI, bat to top 2 levels.
nemo
parents:
7274
diff
changeset
|
891 |
x, y, trackFall: LongInt; |
6770
7d2c6cdb816a
Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents:
6769
diff
changeset
|
892 |
begin |
7716 | 893 |
Targ:= Targ; // avoid compiler hint |
894 |
||
7471 | 895 |
if Level = 1 then trackFall:= afTrackFall |
7348
2a69f2ed9273
Limit firepunch/whip drowning checks to max AI, bat to top 2 levels.
nemo
parents:
7274
diff
changeset
|
896 |
else trackFall:= 0; |
7471 | 897 |
|
7200
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
898 |
ap.ExplR:= 0; |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
899 |
ap.Time:= 0; |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
900 |
ap.Power:= 1; |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
901 |
x:= hwRound(Me^.X); |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
902 |
y:= hwRound(Me^.Y); |
7154 | 903 |
|
7200
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
904 |
// check left direction |
8924 | 905 |
{first RateShove checks farthermost of two whip's AmmoShove attacks |
906 |
to encourage distant attacks (damaged hog is excluded from view of second |
|
7200
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
907 |
RateShove call)} |
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8924
diff
changeset
|
908 |
v1:= RateShove(Me, x - 13, y |
7210
2ff30b79d2b0
- Adjust some consts so whip and firepunch work perfectly
unc0rr
parents:
7208
diff
changeset
|
909 |
, 30, 30, 25 |
7348
2a69f2ed9273
Limit firepunch/whip drowning checks to max AI, bat to top 2 levels.
nemo
parents:
7274
diff
changeset
|
910 |
, -1, -0.8, trackFall or afSetSkip); |
7200
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
911 |
v1:= v1 + |
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8924
diff
changeset
|
912 |
RateShove(Me, x - 2, y |
7210
2ff30b79d2b0
- Adjust some consts so whip and firepunch work perfectly
unc0rr
parents:
7208
diff
changeset
|
913 |
, 30, 30, 25 |
7348
2a69f2ed9273
Limit firepunch/whip drowning checks to max AI, bat to top 2 levels.
nemo
parents:
7274
diff
changeset
|
914 |
, -1, -0.8, trackFall); |
7200
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
915 |
// now try opposite direction |
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8924
diff
changeset
|
916 |
v2:= RateShove(Me, x + 13, y |
7210
2ff30b79d2b0
- Adjust some consts so whip and firepunch work perfectly
unc0rr
parents:
7208
diff
changeset
|
917 |
, 30, 30, 25 |
7348
2a69f2ed9273
Limit firepunch/whip drowning checks to max AI, bat to top 2 levels.
nemo
parents:
7274
diff
changeset
|
918 |
, 1, -0.8, trackFall or afSetSkip); |
7200
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
919 |
v2:= v2 + |
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8924
diff
changeset
|
920 |
RateShove(Me, x + 2, y |
7210
2ff30b79d2b0
- Adjust some consts so whip and firepunch work perfectly
unc0rr
parents:
7208
diff
changeset
|
921 |
, 30, 30, 25 |
7348
2a69f2ed9273
Limit firepunch/whip drowning checks to max AI, bat to top 2 levels.
nemo
parents:
7274
diff
changeset
|
922 |
, 1, -0.8, trackFall); |
7154 | 923 |
|
8924 | 924 |
if (v2 > v1) |
7200
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
925 |
or {don't encourage turning for no gain}((v2 = v1) and (not Me^.dX.isNegative)) then |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
926 |
begin |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
927 |
ap.Angle:= 1; |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
928 |
valueResult:= v2 |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
929 |
end |
8924 | 930 |
else |
7200
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
931 |
begin |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
932 |
ap.Angle:= -1; |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
933 |
valueResult:= v1 |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
934 |
end; |
8924 | 935 |
|
7200
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
936 |
if valueResult <= 0 then |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
937 |
valueResult:= BadTurn |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
938 |
else |
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
939 |
inc(valueResult); |
6770
7d2c6cdb816a
Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents:
6769
diff
changeset
|
940 |
|
7200
744c8a5546c6
New bright and shiny TestFirepunch which actually works
unc0rr
parents:
7197
diff
changeset
|
941 |
TestWhip:= valueResult; |
6770
7d2c6cdb816a
Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents:
6769
diff
changeset
|
942 |
end; |
7d2c6cdb816a
Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents:
6769
diff
changeset
|
943 |
|
8959 | 944 |
function TestKamikaze(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
7471 | 945 |
const step = 8; |
7474 | 946 |
var valueResult, i, v, tx: LongInt; |
7471 | 947 |
trackFall: LongInt; |
948 |
t, d, x, y, dx, dy, cx: real; |
|
949 |
begin |
|
950 |
ap.ExplR:= 0; |
|
951 |
ap.Time:= 0; |
|
952 |
ap.Power:= 1; |
|
953 |
||
8924 | 954 |
if Level = 1 then |
7471 | 955 |
trackFall:= afTrackFall |
956 |
else if Level = 2 then |
|
957 |
trackFall:= 0 |
|
958 |
else |
|
959 |
exit(BadTurn); |
|
8924 | 960 |
|
7471 | 961 |
valueResult:= 0; |
7486 | 962 |
v:= 0; |
7471 | 963 |
|
964 |
x:= hwFloat2Float(Me^.X); |
|
965 |
y:= hwFloat2Float(Me^.Y); |
|
8959 | 966 |
d:= sqrt(sqr(Targ.Point.X - x) + sqr(Targ.Point.Y - y)); |
7486 | 967 |
if d < 10 then |
7474 | 968 |
begin |
969 |
dx:= 0; |
|
970 |
dy:= 8; |
|
971 |
ap.Angle:= 2048 |
|
972 |
end |
|
973 |
else |
|
974 |
begin |
|
975 |
t:= step / d; |
|
8959 | 976 |
dx:= (Targ.Point.X - x) * t; |
977 |
dy:= (Targ.Point.Y - y) * t; |
|
7471 | 978 |
|
7474 | 979 |
ap.Angle:= DxDy2AttackAnglef(dx, -dy) |
980 |
end; |
|
8924 | 981 |
|
7471 | 982 |
if dx >= 0 then cx:= 0.45 else cx:= -0.45; |
983 |
||
984 |
for i:= 0 to 512 div step - 2 do |
|
985 |
begin |
|
8924 | 986 |
valueResult:= valueResult + |
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8924
diff
changeset
|
987 |
RateShove(Me, trunc(x), trunc(y) |
7471 | 988 |
, 30, 30, 25 |
989 |
, cx, -0.9, trackFall or afSetSkip); |
|
8924 | 990 |
|
7471 | 991 |
x:= x + dx; |
992 |
y:= y + dy; |
|
993 |
end; |
|
7474 | 994 |
if dx = 0 then |
995 |
begin |
|
996 |
x:= hwFloat2Float(Me^.X); |
|
997 |
y:= hwFloat2Float(Me^.Y); |
|
998 |
tx:= trunc(x); |
|
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8924
diff
changeset
|
999 |
v:= RateShove(Me, tx, trunc(y) |
7486 | 1000 |
, 30, 30, 25 |
1001 |
, -cx, -0.9, trackFall); |
|
7474 | 1002 |
for i:= 1 to 512 div step - 2 do |
1003 |
begin |
|
1004 |
y:= y + dy; |
|
8924 | 1005 |
v:= v + |
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8924
diff
changeset
|
1006 |
RateShove(Me, tx, trunc(y) |
7474 | 1007 |
, 30, 30, 25 |
1008 |
, -cx, -0.9, trackFall or afSetSkip); |
|
1009 |
end |
|
1010 |
end; |
|
1011 |
if v > valueResult then |
|
1012 |
begin |
|
1013 |
ap.Angle:= -2048; |
|
1014 |
valueResult:= v |
|
1015 |
end; |
|
7716 | 1016 |
|
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8924
diff
changeset
|
1017 |
v:= RateShove(Me, trunc(x), trunc(y) |
7471 | 1018 |
, 30, 30, 25 |
1019 |
, cx, -0.9, trackFall); |
|
1020 |
valueResult:= valueResult + v - KillScore * friendlyfactor div 100 * 1024; |
|
7716 | 1021 |
|
7471 | 1022 |
if v < 65536 then |
1023 |
inc(valueResult, RateExplosion(Me, trunc(x), trunc(y), 30)); |
|
1024 |
||
1025 |
TestKamikaze:= valueResult; |
|
1026 |
end; |
|
1027 |
||
8959 | 1028 |
function TestHammer(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
5645 | 1029 |
var rate: LongInt; |
1030 |
begin |
|
1031 |
Level:= Level; // avoid compiler hint |
|
7716 | 1032 |
Targ:= Targ; |
1033 |
||
5645 | 1034 |
ap.ExplR:= 0; |
1035 |
ap.Time:= 0; |
|
1036 |
ap.Power:= 1; |
|
1037 |
ap.Angle:= 0; |
|
8924 | 1038 |
|
7178
c61cfc9eb29d
Don't make unnecessary calls to TestWhip, TestFirePunch, TestBaseballBat and TestHammer functions as they have no need to take Targ parameter into account and thus may only be called once per position
unc0rr
parents:
7161
diff
changeset
|
1039 |
rate:= RateHammer(Me); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1040 |
if rate = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1041 |
rate:= BadTurn; |
5645 | 1042 |
TestHammer:= rate; |
1043 |
end; |
|
1044 |
||
8959 | 1045 |
function TestAirAttack(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
556
49675457d76e
Bots aims not directly at the center of enemy hedgehog
unc0rr
parents:
554
diff
changeset
|
1046 |
const cShift = 4; |
6775 | 1047 |
var bombsSpeed, X, Y, dY: real; |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
1048 |
b: array[0..9] of boolean; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
1049 |
dmg: array[0..9] of LongInt; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
1050 |
fexit: boolean; |
2695 | 1051 |
i, t, valueResult: LongInt; |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
1052 |
begin |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
1053 |
ap.ExplR:= 0; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
1054 |
ap.Time:= 0; |
9844 | 1055 |
if (Level > 3) or (cGravityf = 0) then |
7041 | 1056 |
exit(BadTurn); |
554 | 1057 |
|
7132 | 1058 |
ap.Angle:= 0; |
8959 | 1059 |
ap.AttackPutX:= Targ.Point.X; |
1060 |
ap.AttackPutY:= Targ.Point.Y; |
|
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
1061 |
|
6775 | 1062 |
bombsSpeed:= hwFloat2Float(cBombsSpeed); |
8959 | 1063 |
X:= Targ.Point.X - 135 - cShift; // hh center - cShift |
1064 |
X:= X - bombsSpeed * sqrt(((Targ.Point.Y + 128) * 2) / cGravityf); |
|
6775 | 1065 |
Y:= -128; |
1066 |
dY:= 0; |
|
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
1067 |
|
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
1068 |
for i:= 0 to 9 do |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
1069 |
begin |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
1070 |
b[i]:= true; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
1071 |
dmg[i]:= 0 |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
1072 |
end; |
2695 | 1073 |
valueResult:= 0; |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
1074 |
|
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
1075 |
repeat |
6775 | 1076 |
X:= X + bombsSpeed; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1077 |
Y:= Y + dY; |
6775 | 1078 |
dY:= dY + cGravityf; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1079 |
fexit:= true; |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
1080 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1081 |
for i:= 0 to 9 do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1082 |
if b[i] then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1083 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1084 |
fexit:= false; |
6992 | 1085 |
if TestColl(trunc(X) + LongWord(i * 30), trunc(Y), 4) then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1086 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1087 |
b[i]:= false; |
6992 | 1088 |
dmg[i]:= RateExplosion(Me, trunc(X) + LongWord(i * 30), trunc(Y), 58) |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1089 |
// 58 (instead of 60) for better prediction (hh moves after explosion of one of the rockets) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1090 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1091 |
end; |
6775 | 1092 |
until fexit or (Y > cWaterLine); |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
1093 |
|
2695 | 1094 |
for i:= 0 to 5 do inc(valueResult, dmg[i]); |
1095 |
t:= valueResult; |
|
8959 | 1096 |
ap.AttackPutX:= Targ.Point.X - 60; |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
1097 |
|
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
1098 |
for i:= 0 to 3 do |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
1099 |
begin |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
1100 |
dec(t, dmg[i]); |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
1101 |
inc(t, dmg[i + 6]); |
2695 | 1102 |
if t > valueResult then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1103 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1104 |
valueResult:= t; |
8959 | 1105 |
ap.AttackPutX:= Targ.Point.X - 30 - cShift + i * 30 |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1106 |
end |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
1107 |
end; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
1108 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1109 |
if valueResult <= 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1110 |
valueResult:= BadTurn; |
2695 | 1111 |
TestAirAttack:= valueResult; |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
1112 |
end; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
534
diff
changeset
|
1113 |
|
3370 | 1114 |
|
8959 | 1115 |
function TestTeleport(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
3370 | 1116 |
var |
3439 | 1117 |
i, failNum: longword; |
1118 |
maxTop: longword; |
|
3370 | 1119 |
begin |
3439 | 1120 |
TestTeleport := BadTurn; |
7041 | 1121 |
exit(BadTurn); |
3439 | 1122 |
Level:= Level; // avoid compiler hint |
6888 | 1123 |
//FillBonuses(true, [gtCase]); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1124 |
if bonuses.Count = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1125 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1126 |
if Me^.Health <= 100 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1127 |
begin |
8959 | 1128 |
maxTop := Targ.Point.Y - cHHRadius * 2; |
8924 | 1129 |
|
8959 | 1130 |
while not TestColl(Targ.Point.X, maxTop, cHHRadius) and (maxTop > topY + cHHRadius * 2 + 1) do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1131 |
dec(maxTop, cHHRadius*2); |
8959 | 1132 |
if not TestColl(Targ.Point.X, maxTop + cHHRadius, cHHRadius) then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1133 |
begin |
8959 | 1134 |
ap.AttackPutX := Targ.Point.X; |
3439 | 1135 |
ap.AttackPutY := maxTop + cHHRadius; |
8959 | 1136 |
TestTeleport := Targ.Point.Y - maxTop; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1137 |
end; |
3439 | 1138 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1139 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1140 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1141 |
begin |
3439 | 1142 |
failNum := 0; |
3697 | 1143 |
repeat |
3439 | 1144 |
i := random(bonuses.Count); |
1145 |
inc(failNum); |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1146 |
until not TestColl(bonuses.ar[i].X, bonuses.ar[i].Y - cHHRadius - bonuses.ar[i].Radius, cHHRadius) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1147 |
or (failNum = bonuses.Count*2); |
8924 | 1148 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1149 |
if failNum < bonuses.Count*2 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1150 |
begin |
3439 | 1151 |
ap.AttackPutX := bonuses.ar[i].X; |
1152 |
ap.AttackPutY := bonuses.ar[i].Y - cHHRadius - bonuses.ar[i].Radius; |
|
1153 |
TestTeleport := 0; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
1154 |
end; |
3439 | 1155 |
end; |
3370 | 1156 |
end; |
1157 |
||
7398 | 1158 |
|
7416
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7398
diff
changeset
|
1159 |
procedure checkCakeWalk(Me, Gear: PGear; var ap: TAttackParams); |
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7398
diff
changeset
|
1160 |
var i: Longword; |
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7398
diff
changeset
|
1161 |
v: LongInt; |
7398 | 1162 |
begin |
8370 | 1163 |
while (not TestColl(hwRound(Gear^.X), hwRound(Gear^.Y), 6)) and (Gear^.Y.Round < LongWord(LAND_HEIGHT)) do |
7416
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7398
diff
changeset
|
1164 |
Gear^.Y:= Gear^.Y + _1; |
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7398
diff
changeset
|
1165 |
|
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7398
diff
changeset
|
1166 |
for i:= 0 to 2040 do |
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7398
diff
changeset
|
1167 |
begin |
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7398
diff
changeset
|
1168 |
cakeStep(Gear); |
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7398
diff
changeset
|
1169 |
v:= RateExplosion(Me, hwRound(Gear^.X), hwRound(Gear^.Y), cakeDmg * 2, afTrackFall); |
8924 | 1170 |
if v > ap.Power then |
7416
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7398
diff
changeset
|
1171 |
begin |
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7398
diff
changeset
|
1172 |
ap.ExplX:= hwRound(Gear^.X); |
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7398
diff
changeset
|
1173 |
ap.ExplY:= hwRound(Gear^.Y); |
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7398
diff
changeset
|
1174 |
ap.Power:= v |
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7398
diff
changeset
|
1175 |
end |
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7398
diff
changeset
|
1176 |
end; |
7398 | 1177 |
end; |
1178 |
||
8959 | 1179 |
function TestCake(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
7398 | 1180 |
var valueResult, v1, v2: LongInt; |
1181 |
cake: TGear; |
|
1182 |
begin |
|
7716 | 1183 |
Targ:= Targ; // avoid compiler hint |
1184 |
||
7501 | 1185 |
if (Level > 2) then |
1186 |
exit(BadTurn); |
|
7716 | 1187 |
|
7398 | 1188 |
ap.ExplR:= 0; |
1189 |
ap.Time:= 0; |
|
7416
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7398
diff
changeset
|
1190 |
ap.Power:= BadTurn; // use it as max score value in checkCakeWalk |
7398 | 1191 |
|
7721 | 1192 |
//FillChar(cake, sizeof(cake), 0); |
7398 | 1193 |
cake.Radius:= 7; |
8751
4609823efc94
More flagging of Land values. Also use less than for tests of non-terrain, instead of "and $FF00 = 0". Saves a couple of ops, which actually matters a small amount in a few places.
nemo
parents:
8744
diff
changeset
|
1194 |
cake.CollisionMask:= lfNotCurrentMask; |
7752 | 1195 |
cake.Hedgehog:= Me^.Hedgehog; |
7398 | 1196 |
|
1197 |
// check left direction |
|
1198 |
cake.Angle:= 3; |
|
1199 |
cake.dX.isNegative:= true; |
|
1200 |
cake.X:= Me^.X - _3; |
|
1201 |
cake.Y:= Me^.Y; |
|
7416
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7398
diff
changeset
|
1202 |
checkCakeWalk(Me, @cake, ap); |
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7398
diff
changeset
|
1203 |
v1:= ap.Power; |
7398 | 1204 |
|
1205 |
// now try opposite direction |
|
1206 |
cake.Angle:= 1; |
|
1207 |
cake.dX.isNegative:= false; |
|
1208 |
cake.X:= Me^.X + _3; |
|
1209 |
cake.Y:= Me^.Y; |
|
7416
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7398
diff
changeset
|
1210 |
checkCakeWalk(Me, @cake, ap); |
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7398
diff
changeset
|
1211 |
v2:= ap.Power; |
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7398
diff
changeset
|
1212 |
|
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7398
diff
changeset
|
1213 |
ap.Power:= 1; |
7398 | 1214 |
|
1215 |
if (v2 > v1) then |
|
1216 |
begin |
|
1217 |
ap.Angle:= 1; |
|
1218 |
valueResult:= v2 |
|
1219 |
end |
|
1220 |
else |
|
1221 |
begin |
|
1222 |
ap.Angle:= -1; |
|
1223 |
valueResult:= v1 |
|
1224 |
end; |
|
1225 |
||
1226 |
if valueResult <= 0 then |
|
1227 |
valueResult:= BadTurn; |
|
1228 |
||
1229 |
TestCake:= valueResult; |
|
1230 |
end; |
|
1231 |
||
9722
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1232 |
function TestDynamite(Me: PGear; Targ: TTarget; Level: LongInt; var ap: TAttackParams): LongInt; |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1233 |
var valueResult: LongInt; |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1234 |
x, y, dx, dy: real; |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1235 |
EX, EY, t: LongInt; |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1236 |
begin |
9790 | 1237 |
Targ:= Targ; // avoid compiler hint |
1238 |
||
9722
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1239 |
x:= hwFloat2Float(Me^.X) + hwSign(Me^.dX) * 7; |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1240 |
y:= hwFloat2Float(Me^.Y); |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1241 |
dx:= hwSign(Me^.dX) * 0.03; |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1242 |
dy:= 0; |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1243 |
t:= 5000; |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1244 |
repeat |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1245 |
dec(t); |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1246 |
x:= x + dx; |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1247 |
dy:= dy + cGravityf; |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1248 |
y:= y + dy; |
10015 | 1249 |
|
9722
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1250 |
if TestColl(trunc(x), trunc(y), 3) then |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1251 |
t:= 0; |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1252 |
until t = 0; |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1253 |
|
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1254 |
EX:= trunc(x); |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1255 |
EY:= trunc(y); |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1256 |
|
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1257 |
if Level = 1 then |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1258 |
valueResult:= RateExplosion(Me, EX, EY, 76, afTrackFall or afErasesLand) |
10015 | 1259 |
else |
9722
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1260 |
valueResult:= RateExplosion(Me, EX, EY, 76); |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1261 |
|
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1262 |
if (valueResult > 0) then |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1263 |
begin |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1264 |
ap.Angle:= 0; |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1265 |
ap.Power:= 1; |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1266 |
ap.Time:= 0; |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1267 |
ap.ExplR:= 150; |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1268 |
ap.ExplX:= EX; |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1269 |
ap.ExplY:= EY |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1270 |
end else |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1271 |
valueResult:= BadTurn; |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1272 |
|
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1273 |
TestDynamite:= valueResult |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1274 |
end; |
22dba2d8de93
Quick and simple dynamite AI without precalculated retreat and without accurate dynamite physics model (no bounce). Still does pretty well, using it mostly off cliffs.
unc0rr
parents:
9495
diff
changeset
|
1275 |
|
4 | 1276 |
end. |