author  Wuzzy <Wuzzy2@mail.ru> 
Mon, 06 Jul 2020 16:55:35 +0200  
changeset 15693  2aedd8ca836c 
parent 15690  c4d7eb75fd8a 
child 15726  12973ea952c6 
permissions  rwrr 
71  1 
(* 
1066  2 
* Hedgewars, a free turn based strategy game 
11046  3 
* Copyright (c) 20042015 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:
10015
diff
changeset

16 
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 021101301 USA 
71  17 
*) 
18 

2599  19 
{$INCLUDE "options.inc"} 
2587
0dfa56a8513c
fix a segfault in the iphone simulator by moving options.inc at the beginning of the file
koda
parents:
2376
diff
changeset

20 

4  21 
unit uAIMisc; 
22 
interface 

4368  23 
uses SDLh, uConsts, uFloat, uTypes; 
369  24 

3370  25 
const MAXBONUS = 1024; 
7161
21a9c70b2070
Name the flags for fall tracking and indicating whether the explosion erases terrain.
nemo
parents:
7154
diff
changeset

26 

21a9c70b2070
Name the flags for fall tracking and indicating whether the explosion erases terrain.
nemo
parents:
7154
diff
changeset

27 
afTrackFall = $00000001; 
21a9c70b2070
Name the flags for fall tracking and indicating whether the explosion erases terrain.
nemo
parents:
7154
diff
changeset

28 
afErasesLand = $00000002; 
21a9c70b2070
Name the flags for fall tracking and indicating whether the explosion erases terrain.
nemo
parents:
7154
diff
changeset

29 
afSetSkip = $00000004; 
15608
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15389
diff
changeset

30 
afIgnoreMe = $00000008; 
7161
21a9c70b2070
Name the flags for fall tracking and indicating whether the explosion erases terrain.
nemo
parents:
7154
diff
changeset

31 

8013  32 
BadTurn = Low(LongInt) div 4; 
7161
21a9c70b2070
Name the flags for fall tracking and indicating whether the explosion erases terrain.
nemo
parents:
7154
diff
changeset

33 

8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

34 
type TTarget = record // starting to look more and more like a gear 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

35 
Point: TPoint; 
8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

36 
Score, Radius: LongInt; 
8969  37 
State: LongWord; 
8952
a6ee1e7310fb
trying to make AI aware of mine/explosive break point. also remove redundant test.
nemo
parents:
8951
diff
changeset

38 
Density: real; 
8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

39 
skip, matters, dead: boolean; 
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

40 
Kind: TGearType; 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

41 
end; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

42 
TTargets = record 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

43 
Count: Longword; 
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

44 
ar: array[0..Pred(256)] of TTarget; 
8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

45 
reset: boolean; 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

46 
end; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

47 
TJumpType = (jmpNone, jmpHJump, jmpLJump); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

48 
TGoInfo = record 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

49 
Ticks: Longword; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

50 
FallPix: Longword; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

51 
JumpType: TJumpType; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

52 
end; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

53 
TBonus = record 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

54 
X, Y: LongInt; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

55 
Radius: LongInt; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

56 
Score: LongInt; 
10015  57 
end; 
8026
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
8013
diff
changeset

58 

10164
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

59 
TBonuses = record 
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

60 
activity: boolean; 
15366  61 
Count : LongInt; 
10015  62 
ar : array[0..Pred(MAXBONUS)] of TBonus; 
63 
end; 

8026
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
8013
diff
changeset

64 

4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
8013
diff
changeset

65 
Twalkbonuses = record 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
8013
diff
changeset

66 
Count: Longword; 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
8013
diff
changeset

67 
ar: array[0..Pred(MAXBONUS div 8)] of TBonus; // don't use too many 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
8013
diff
changeset

68 
end; 
64  69 

3038  70 
procedure initModule; 
71 
procedure freeModule; 

2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset

72 

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

73 
procedure FillTargets; 
8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

74 
procedure ResetTargets; inline; 
7375
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

75 
procedure AddBonus(x, y: LongInt; r: Longword; s: LongInt); inline; 
6888  76 
procedure FillBonuses(isAfterAttack: boolean); 
6767
ccbf07b38a43
First pass at making AI drowning aware. No concerns of performance, only applied to bazooka (not bat/fp etc)
nemo
parents:
6766
diff
changeset

77 
procedure AwareOfExplosion(x, y, r: LongInt); inline; 
6986
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6952
diff
changeset

78 

409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6952
diff
changeset

79 
function RatePlace(Gear: PGear): LongInt; 
13668  80 
function CheckWrap(x: real): real; inline; 
6986
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6952
diff
changeset

81 
function TestColl(x, y, r: LongInt): boolean; inline; 
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:
7164
diff
changeset

82 
function TestCollExcludingObjects(x, y, r: LongInt): boolean; inline; 
6986
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6952
diff
changeset

83 
function TestCollExcludingMe(Me: PGear; x, y, r: LongInt): boolean; inline; 
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6952
diff
changeset

84 

409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6952
diff
changeset

85 
function RateExplosion(Me: PGear; x, y, r: LongInt): LongInt; inline; 
8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

86 
function RateExplosion(Me: PGear; x, y, r: LongInt; Flags: LongWord): LongInt; inline; 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

87 
function RealRateExplosion(Me: PGear; x, y, r: LongInt; Flags: LongWord): LongInt; 
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

88 
function RateShove(Me: PGear; x, y, r, power, kick: LongInt; gdX, gdY: real; Flags: LongWord): LongInt; 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

89 
function RateShotgun(Me: PGear; gdX, gdY: real; x, y: LongInt): LongInt; 
15617  90 
function RateSeduction(Me: PGear): LongInt; 
15685  91 
function RateResurrector(Me: PGear): LongInt; 
6986
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6952
diff
changeset

92 
function RateHammer(Me: PGear): LongInt; 
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6952
diff
changeset

93 

409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6952
diff
changeset

94 
function HHGo(Gear, AltGear: PGear; var GoInfo: TGoInfo): boolean; 
14212
ca179b615c0b
adding X offset seems to improve chance of drownings
nemo
parents:
13668
diff
changeset

95 
function AIrndSign(num: LongInt): LongInt; inline; 
ca179b615c0b
adding X offset seems to improve chance of drownings
nemo
parents:
13668
diff
changeset

96 
function AIrndOffset(targ: TTarget; Level: LongWord): LongInt; inline; 
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

97 

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

98 
var ThinkingHH: PGear; 
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

99 
Targets: TTargets; 
921
8dd71d960cbc
If there's more hedgehogs in AI's team than in others, then it will be less afraid to give damage to friend hedgehog
unc0rr
parents:
883
diff
changeset

100 

10164
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

101 
bonuses: TBonuses; 
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset

102 

8026
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
8013
diff
changeset

103 
walkbonuses: Twalkbonuses; 
7375
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

104 

7471  105 
const KillScore = 200; 
15685  106 
ResurrectScore = 100; 
7471  107 
var friendlyfactor: LongInt = 300; 
8884
08fe08651130
set translucency on fruit theme water, clamp size to even number (same sdl window resize) and honouring min size, reduce calls to dmgmod a bit
nemo
parents:
8845
diff
changeset

108 
var dmgMod: real = 1.0; 
7716  109 

3370  110 
implementation 
15690
c4d7eb75fd8a
AI: Add aiGravity and aiGravityf variables
Wuzzy <Wuzzy2@mail.ru>
parents:
15685
diff
changeset

111 
uses uCollisions, uVariables, uUtils, uGearsUtils, uAIAmmoTests; 
3370  112 

8924  113 
var 
3370  114 
KnownExplosion: record 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

115 
X, Y, Radius: LongInt 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

116 
end = (X: 0; Y: 0; Radius: 0); 
4  117 

8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

118 
procedure ResetTargets; inline; 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

119 
var i: LongWord; 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

120 
begin 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

121 
if Targets.reset then 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

122 
for i:= 0 to Targets.Count do 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

123 
Targets.ar[i].dead:= false; 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

124 
Targets.reset:= false; 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

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

126 
procedure FillTargets; 
9137
d987230b85ed
fixed all engine compilation hints and notes (that I could see)
sheepluva
parents:
9080
diff
changeset

127 
var //i, t: Longword; 
6011
519f8a58c021
Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents:
5881
diff
changeset

128 
f, e: LongInt; 
8956
e0e914642e73
Also have AI consider mines that will almost certainly be duds by the time he gets to them. I'm mostly using it to test AI behaviour w/ firepunch/whip/bat on a mineheavy map.
nemo
parents:
8955
diff
changeset

129 
Gear: PGear; 
4  130 
begin 
131 
Targets.Count:= 0; 

8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

132 
Targets.reset:= false; 
921
8dd71d960cbc
If there's more hedgehogs in AI's team than in others, then it will be less afraid to give damage to friend hedgehog
unc0rr
parents:
883
diff
changeset

133 
f:= 0; 
8dd71d960cbc
If there's more hedgehogs in AI's team than in others, then it will be less afraid to give damage to friend hedgehog
unc0rr
parents:
883
diff
changeset

134 
e:= 0; 
8956
e0e914642e73
Also have AI consider mines that will almost certainly be duds by the time he gets to them. I'm mostly using it to test AI behaviour w/ firepunch/whip/bat on a mineheavy map.
nemo
parents:
8955
diff
changeset

135 
Gear:= GearsList; 
e0e914642e73
Also have AI consider mines that will almost certainly be duds by the time he gets to them. I'm mostly using it to test AI behaviour w/ firepunch/whip/bat on a mineheavy map.
nemo
parents:
8955
diff
changeset

136 
while Gear <> nil do 
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

137 
begin 
8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

138 
if (((Gear^.Kind = gtHedgehog) and 
8956
e0e914642e73
Also have AI consider mines that will almost certainly be duds by the time he gets to them. I'm mostly using it to test AI behaviour w/ firepunch/whip/bat on a mineheavy map.
nemo
parents:
8955
diff
changeset

139 
(Gear <> ThinkingHH) and 
e0e914642e73
Also have AI consider mines that will almost certainly be duds by the time he gets to them. I'm mostly using it to test AI behaviour w/ firepunch/whip/bat on a mineheavy map.
nemo
parents:
8955
diff
changeset

140 
(Gear^.Health > Gear^.Damage) and 
9136  141 
(not Gear^.Hedgehog^.Team^.hasgone)) or 
15685  142 
((Gear^.Kind = gtGrave) and 
143 
(Gear^.Health = 0)) or 

8956
e0e914642e73
Also have AI consider mines that will almost certainly be duds by the time he gets to them. I'm mostly using it to test AI behaviour w/ firepunch/whip/bat on a mineheavy map.
nemo
parents:
8955
diff
changeset

144 
((Gear^.Kind = gtExplosives) and 
e0e914642e73
Also have AI consider mines that will almost certainly be duds by the time he gets to them. I'm mostly using it to test AI behaviour w/ firepunch/whip/bat on a mineheavy map.
nemo
parents:
8955
diff
changeset

145 
(Gear^.Health > Gear^.Damage)) or 
e0e914642e73
Also have AI consider mines that will almost certainly be duds by the time he gets to them. I'm mostly using it to test AI behaviour w/ firepunch/whip/bat on a mineheavy map.
nemo
parents:
8955
diff
changeset

146 
((Gear^.Kind = gtMine) and 
8972
f01b836d702e
I was using this to test firepunching likely duds, but most of the time that would probably just make him bazooka them
nemo
parents:
8971
diff
changeset

147 
(Gear^.Health = 0) and 
f01b836d702e
I was using this to test firepunching likely duds, but most of the time that would probably just make him bazooka them
nemo
parents:
8971
diff
changeset

148 
(Gear^.Damage < 35)) 
10015  149 
) and 
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

150 
(Targets.Count < 256) then 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

151 
begin 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

152 
with Targets.ar[Targets.Count] do 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2716
diff
changeset

153 
begin 
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

154 
skip:= false; 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

155 
dead:= false; 
8956
e0e914642e73
Also have AI consider mines that will almost certainly be duds by the time he gets to them. I'm mostly using it to test AI behaviour w/ firepunch/whip/bat on a mineheavy map.
nemo
parents:
8955
diff
changeset

156 
Kind:= Gear^.Kind; 
8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

157 
Radius:= Gear^.Radius; 
8963
1a8335f0d968
Apply radius consistently. Still doesn't explain AI fail I think, although I can't run it right now.
nemo
parents:
8962
diff
changeset

158 
Density:= hwFloat2Float(Gear^.Density)/3; 
8969  159 
State:= Gear^.State; 
8956
e0e914642e73
Also have AI consider mines that will almost certainly be duds by the time he gets to them. I'm mostly using it to test AI behaviour w/ firepunch/whip/bat on a mineheavy map.
nemo
parents:
8955
diff
changeset

160 
matters:= (Gear^.AIHints and aihDoesntMatter) = 0; 
8924  161 

8956
e0e914642e73
Also have AI consider mines that will almost certainly be duds by the time he gets to them. I'm mostly using it to test AI behaviour w/ firepunch/whip/bat on a mineheavy map.
nemo
parents:
8955
diff
changeset

162 
Point.X:= hwRound(Gear^.X); 
e0e914642e73
Also have AI consider mines that will almost certainly be duds by the time he gets to them. I'm mostly using it to test AI behaviour w/ firepunch/whip/bat on a mineheavy map.
nemo
parents:
8955
diff
changeset

163 
Point.Y:= hwRound(Gear^.Y); 
e0e914642e73
Also have AI consider mines that will almost certainly be duds by the time he gets to them. I'm mostly using it to test AI behaviour w/ firepunch/whip/bat on a mineheavy map.
nemo
parents:
8955
diff
changeset

164 
if (Gear^.Kind = gtHedgehog) then 
8952
a6ee1e7310fb
trying to make AI aware of mine/explosive break point. also remove redundant test.
nemo
parents:
8951
diff
changeset

165 
begin 
8956
e0e914642e73
Also have AI consider mines that will almost certainly be duds by the time he gets to them. I'm mostly using it to test AI behaviour w/ firepunch/whip/bat on a mineheavy map.
nemo
parents:
8955
diff
changeset

166 
if (Gear^.Hedgehog^.Team^.Clan = CurrentTeam^.Clan) then 
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

167 
begin 
8956
e0e914642e73
Also have AI consider mines that will almost certainly be duds by the time he gets to them. I'm mostly using it to test AI behaviour w/ firepunch/whip/bat on a mineheavy map.
nemo
parents:
8955
diff
changeset

168 
Score:= Gear^.Damage  Gear^.Health; 
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

169 
inc(f) 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

170 
end 
10015  171 
else 
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

172 
begin 
8956
e0e914642e73
Also have AI consider mines that will almost certainly be duds by the time he gets to them. I'm mostly using it to test AI behaviour w/ firepunch/whip/bat on a mineheavy map.
nemo
parents:
8955
diff
changeset

173 
Score:= Gear^.Health  Gear^.Damage; 
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

174 
inc(e) 
8952
a6ee1e7310fb
trying to make AI aware of mine/explosive break point. also remove redundant test.
nemo
parents:
8951
diff
changeset

175 
end; 
a6ee1e7310fb
trying to make AI aware of mine/explosive break point. also remove redundant test.
nemo
parents:
8951
diff
changeset

176 
end 
15685  177 
else if Gear^.Kind = gtGrave then 
178 
if (Gear^.Hedgehog^.Team^.Clan = CurrentTeam^.Clan) then 

179 
begin 

180 
Score:= ResurrectScore; 

181 
inc(f); 

182 
end 

183 
else 

184 
begin 

185 
Score:= ResurrectScore; 

186 
inc(e); 

187 
end 

8956
e0e914642e73
Also have AI consider mines that will almost certainly be duds by the time he gets to them. I'm mostly using it to test AI behaviour w/ firepunch/whip/bat on a mineheavy map.
nemo
parents:
8955
diff
changeset

188 
else if Gear^.Kind = gtExplosives then 
8963
1a8335f0d968
Apply radius consistently. Still doesn't explain AI fail I think, although I can't run it right now.
nemo
parents:
8962
diff
changeset

189 
Score:= Gear^.Health  Gear^.Damage 
10015  190 
else if Gear^.Kind = gtMine then 
8956
e0e914642e73
Also have AI consider mines that will almost certainly be duds by the time he gets to them. I'm mostly using it to test AI behaviour w/ firepunch/whip/bat on a mineheavy map.
nemo
parents:
8955
diff
changeset

191 
Score:= max(0,35Gear^.Damage); 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2716
diff
changeset

192 
end; 
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

193 
inc(Targets.Count) 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

194 
end; 
8956
e0e914642e73
Also have AI consider mines that will almost certainly be duds by the time he gets to them. I'm mostly using it to test AI behaviour w/ firepunch/whip/bat on a mineheavy map.
nemo
parents:
8955
diff
changeset

195 
Gear:= Gear^.NextGear 
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

196 
end; 
921
8dd71d960cbc
If there's more hedgehogs in AI's team than in others, then it will be less afraid to give damage to friend hedgehog
unc0rr
parents:
883
diff
changeset

197 

8dd71d960cbc
If there's more hedgehogs in AI's team than in others, then it will be less afraid to give damage to friend hedgehog
unc0rr
parents:
883
diff
changeset

198 
if e > f then friendlyfactor:= 300 + (e  f) * 30 
5881  199 
else friendlyfactor:= max(30, 300  f * 80 div max(1,e)) 
4  200 
end; 
201 

6767
ccbf07b38a43
First pass at making AI drowning aware. No concerns of performance, only applied to bazooka (not bat/fp etc)
nemo
parents:
6766
diff
changeset

202 
procedure AddBonus(x, y: LongInt; r: Longword; s: LongInt); inline; 
6474
42e9773eedfd
 Improve renderer a bit, disallow nested functions
unc0rr
parents:
6396
diff
changeset

203 
begin 
7164
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

204 
if(bonuses.Count < MAXBONUS) then 
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

205 
begin 
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

206 
bonuses.ar[bonuses.Count].x:= x; 
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

207 
bonuses.ar[bonuses.Count].y:= y; 
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

208 
bonuses.ar[bonuses.Count].Radius:= r; 
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

209 
bonuses.ar[bonuses.Count].Score:= s; 
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

210 
inc(bonuses.Count); 
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

211 
end; 
6474
42e9773eedfd
 Improve renderer a bit, disallow nested functions
unc0rr
parents:
6396
diff
changeset

212 
end; 
42e9773eedfd
 Improve renderer a bit, disallow nested functions
unc0rr
parents:
6396
diff
changeset

213 

7375
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

214 
procedure AddWalkBonus(x, y: LongInt; r: Longword; s: LongInt); inline; 
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

215 
begin 
7378
ac9ce7f033df
Reduce number of walk bonuses further, doubt even 128 are needed. Fix count reset.
nemo
parents:
7375
diff
changeset

216 
if(walkbonuses.Count < MAXBONUS div 8) then 
7375
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

217 
begin 
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

218 
walkbonuses.ar[walkbonuses.Count].x:= x; 
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

219 
walkbonuses.ar[walkbonuses.Count].y:= y; 
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

220 
walkbonuses.ar[walkbonuses.Count].Radius:= r; 
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

221 
walkbonuses.ar[walkbonuses.Count].Score:= s; 
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

222 
inc(walkbonuses.Count); 
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

223 
end; 
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

224 
end; 
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

225 

6888  226 
procedure FillBonuses(isAfterAttack: boolean); 
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

227 
var Gear: PGear; 
549  228 
MyClan: PClan; 
7375
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

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

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

231 
bonuses.Count:= 0; 
10164
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

232 
bonuses.activity:= false; 
4372  233 
MyClan:= ThinkingHH^.Hedgehog^.Team^.Clan; 
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

234 
Gear:= GearsList; 
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

235 
while Gear <> nil do 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2716
diff
changeset

236 
begin 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

237 
case Gear^.Kind of 
10164
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

238 
gtGrenade 
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

239 
, gtClusterBomb 
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

240 
, gtGasBomb 
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

241 
, gtShell 
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

242 
, gtAirAttack 
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

243 
, gtMortar 
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

244 
, gtWatermelon 
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

245 
, gtDrill 
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

246 
, gtAirBomb 
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

247 
, gtCluster 
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

248 
, gtMelonPiece 
14507  249 
, gtBee 
10164
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

250 
, gtMolotov: bonuses.activity:= true; 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

251 
gtCase: 
14264  252 
if (Gear^.AIHints and aihDoesntMatter) = 0 then 
253 
AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y) + 3, 37, 25); 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

254 
gtFlame: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

255 
if (Gear^.State and gsttmpFlag) <> 0 then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

256 
AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y), 20, 50); 
8924  257 
// avoid mines unless they are very likely to be duds, or are duds. also avoid if they are about to blow 
10164
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

258 
gtMine: begin 
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

259 
if (Gear^.State and gstMoving) <> 0 then bonuses.activity:= true; 
10510  260 

14764
b3fa6a19fc25
Computer hog no longer walks into playerplaced mines if >= 90% duds
Wuzzy <Wuzzy2@mail.ru>
parents:
14586
diff
changeset

261 
if ((Gear^.State and gstAttacking) = 0) and (((cMineDudPercent < 90) or ((Gear^.State and gstWait) <> 0) and (Gear^.Health <> 0)) 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

262 
or (isAfterAttack and (Gear^.Health = 0) and (Gear^.Damage > 30))) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

263 
AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y), 50, 50) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

264 
else if (Gear^.State and gstAttacking) <> 0 then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

265 
AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y), 100, 50); // mine is on 
10164
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

266 
end; 
14585  267 
gtAirMine: if ((Gear^.State and gstFrozen) = 0) then AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y), gear^.Angle+5, 30); 
8924  268 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

269 
gtExplosives: 
10164
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

270 
begin 
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

271 
//if (Gear^.State and gstMoving) <> 0 then bonuses.activity:= true; 
8924  272 

10164
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

273 
if isAfterAttack then 
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

274 
AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y), 75, 60 + Gear^.Health); 
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

275 
end; 
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

276 

0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

277 
gtSMine: begin 
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

278 
if (Gear^.State and (gstMoving or gstAttacking)) <> 0 then bonuses.activity:= true; 
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

279 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

280 
AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y), 50, 30); 
10164
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

281 
end; 
8924  282 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

283 
gtDynamite: 
10164
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

284 
begin 
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

285 
bonuses.activity:= true; 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

286 
AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y), 150, 75); 
10164
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

287 
end; 
8924  288 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

289 
gtHedgehog: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

290 
begin 
10510  291 
if (ThinkingHH <> Gear) 
292 
and (((Gear^.State and (gstMoving or gstDrowning or gstHHDeath)) <> 0) 

10164
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

293 
or (Gear^.Health = 0) 
10510  294 
or (Gear^.Damage >= Gear^.Health)) 
10164
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

295 
then begin 
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

296 
bonuses.activity:= true; 
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

297 
end; 
10510  298 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

299 
if Gear^.Damage >= Gear^.Health then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

300 
AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y), 60, 25) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

301 
else 
7385
4acb5c021cb9
Don't consider moving hedgehogs in place rating in after attack mode
unc0rr
parents:
7378
diff
changeset

302 
if isAfterAttack 
4acb5c021cb9
Don't consider moving hedgehogs in place rating in after attack mode
unc0rr
parents:
7378
diff
changeset

303 
and (ThinkingHH^.Hedgehog <> Gear^.Hedgehog) 
4acb5c021cb9
Don't consider moving hedgehogs in place rating in after attack mode
unc0rr
parents:
7378
diff
changeset

304 
and ((hwAbs(Gear^.dX) + hwAbs(Gear^.dY)) < _0_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

305 
if (ClansCount > 2) or (MyClan = Gear^.Hedgehog^.Team^.Clan) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

306 
AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y), 150, 3) // hedgehogfriend 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

307 
else 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

308 
AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y), 100, 3) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

309 
end; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

310 
end; 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2716
diff
changeset

311 
Gear:= Gear^.NextGear 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2716
diff
changeset

312 
end; 
10164
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10140
diff
changeset

313 

71  314 
if isAfterAttack and (KnownExplosion.Radius > 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

315 
with KnownExplosion do 
74  316 
AddBonus(X, Y, Radius + 10, Radius); 
7375
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

317 
if isAfterAttack then 
7378
ac9ce7f033df
Reduce number of walk bonuses further, doubt even 128 are needed. Fix count reset.
nemo
parents:
7375
diff
changeset

318 
begin 
7375
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

319 
for i:= 0 to Pred(walkbonuses.Count) do 
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

320 
with walkbonuses.ar[i] do 
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

321 
AddBonus(X, Y, Radius, Score); 
7378
ac9ce7f033df
Reduce number of walk bonuses further, doubt even 128 are needed. Fix count reset.
nemo
parents:
7375
diff
changeset

322 
walkbonuses.Count:= 0 
ac9ce7f033df
Reduce number of walk bonuses further, doubt even 128 are needed. Fix count reset.
nemo
parents:
7375
diff
changeset

323 
end; 
71  324 
end; 
325 

6986
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6952
diff
changeset

326 
procedure AwareOfExplosion(x, y, r: LongInt); inline; 
71  327 
begin 
6986
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6952
diff
changeset

328 
KnownExplosion.X:= x; 
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6952
diff
changeset

329 
KnownExplosion.Y:= y; 
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6952
diff
changeset

330 
KnownExplosion.Radius:= r 
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

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

332 

371  333 
function RatePlace(Gear: PGear): LongInt; 
334 
var i, r: LongInt; 

2695  335 
rate: LongInt; 
6778  336 
gX, gY: real; 
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

337 
begin 
6778  338 
gX:= hwFloat2Float(Gear^.X); 
339 
gY:= hwFloat2Float(Gear^.Y); 

2695  340 
rate:= 0; 
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

341 
for i:= 0 to Pred(bonuses.Count) do 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2716
diff
changeset

342 
with bonuses.ar[i] do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2716
diff
changeset

343 
begin 
6778  344 
r:= Radius; 
345 
if abs(gXX)+abs(gYY) < Radius then 

346 
r:= trunc(sqrt(sqr(gX  X)+sqr(gY  Y))); 

7164
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

347 
if r < 20 then 
6777
fb71556205f4
Avoid local rate minimums around hog (within 15 pixels). Not tested.
unc0rr
parents:
6776
diff
changeset

348 
inc(rate, Score * Radius) 
fb71556205f4
Avoid local rate minimums around hog (within 15 pixels). Not tested.
unc0rr
parents:
6776
diff
changeset

349 
else if r < Radius then 
fb71556205f4
Avoid local rate minimums around hog (within 15 pixels). Not tested.
unc0rr
parents:
6776
diff
changeset

350 
inc(rate, Score * (Radius  r)) 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2716
diff
changeset

351 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2716
diff
changeset

352 
RatePlace:= rate; 
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

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

354 

13668  355 
function CheckWrap(x: real): real; inline; 
356 
begin 

357 
if WorldEdge = weWrap then 

358 
if (x < leftX) then 

359 
x:= x + (rightX  leftX) 

360 
else if x > rightX then 

361 
x:= x  (rightX  leftX); 

362 
CheckWrap:= x; 

363 
end; 

364 

8845
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

365 
function CheckBounds(x, y, r: Longint): boolean; inline; 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

366 
begin 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

367 
CheckBounds := (((xr) and LAND_WIDTH_MASK) = 0) and 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

368 
(((x+r) and LAND_WIDTH_MASK) = 0) and 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

369 
(((yr) and LAND_HEIGHT_MASK) = 0) and 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

370 
(((y+r) and LAND_HEIGHT_MASK) = 0); 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

371 
end; 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

372 

8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

373 

8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

374 
function TestCollWithEverything(x, y, r: LongInt): boolean; inline; 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

375 
begin 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

376 
if not CheckBounds(x, y, r) then 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

377 
exit(false); 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

378 

8958
3818b38d72c0
simplify mine/explosive damage calc. clear dX in stable explosives. remove 0/4096 in trace routines.
nemo
parents:
8957
diff
changeset

379 
if (Land[yr, xr] <> 0) or 
3818b38d72c0
simplify mine/explosive damage calc. clear dX in stable explosives. remove 0/4096 in trace routines.
nemo
parents:
8957
diff
changeset

380 
(Land[y+r, xr] <> 0) or 
3818b38d72c0
simplify mine/explosive damage calc. clear dX in stable explosives. remove 0/4096 in trace routines.
nemo
parents:
8957
diff
changeset

381 
(Land[yr, x+r] <> 0) or 
3818b38d72c0
simplify mine/explosive damage calc. clear dX in stable explosives. remove 0/4096 in trace routines.
nemo
parents:
8957
diff
changeset

382 
(Land[y+r, x+r] <> 0) then 
8845
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

383 
exit(true); 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

384 

8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

385 
TestCollWithEverything := false; 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

386 
end; 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

387 

8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

388 
function TestCollExcludingObjects(x, y, r: LongInt): boolean; inline; 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

389 
begin 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

390 
if not CheckBounds(x, y, r) then 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

391 
exit(false); 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

392 

8958
3818b38d72c0
simplify mine/explosive damage calc. clear dX in stable explosives. remove 0/4096 in trace routines.
nemo
parents:
8957
diff
changeset

393 
if (Land[yr, xr] > lfAllObjMask) or 
3818b38d72c0
simplify mine/explosive damage calc. clear dX in stable explosives. remove 0/4096 in trace routines.
nemo
parents:
8957
diff
changeset

394 
(Land[y+r, xr] > lfAllObjMask) or 
3818b38d72c0
simplify mine/explosive damage calc. clear dX in stable explosives. remove 0/4096 in trace routines.
nemo
parents:
8957
diff
changeset

395 
(Land[yr, xr] > lfAllObjMask) or 
3818b38d72c0
simplify mine/explosive damage calc. clear dX in stable explosives. remove 0/4096 in trace routines.
nemo
parents:
8957
diff
changeset

396 
(Land[y+r, x+r] > lfAllObjMask) then 
8845
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

397 
exit(true); 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

398 

8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

399 
TestCollExcludingObjects:= false; 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

400 
end; 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

401 

8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

402 
function TestColl(x, y, r: LongInt): boolean; inline; 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

403 
begin 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

404 
if not CheckBounds(x, y, r) then 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

405 
exit(false); 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

406 

13463
f1d349a52bc7
Refactor: lfCurrentHogâ†’lfCurHogCrate, lfNotCurrentMaskâ†’lfNotCurHogCrate
Wuzzy <Wuzzy2@mail.ru>
parents:
11046
diff
changeset

407 
if (Land[yr, xr] and lfNotCurHogCrate <> 0) or 
f1d349a52bc7
Refactor: lfCurrentHogâ†’lfCurHogCrate, lfNotCurrentMaskâ†’lfNotCurHogCrate
Wuzzy <Wuzzy2@mail.ru>
parents:
11046
diff
changeset

408 
(Land[y+r, xr] and lfNotCurHogCrate <> 0) or 
f1d349a52bc7
Refactor: lfCurrentHogâ†’lfCurHogCrate, lfNotCurrentMaskâ†’lfNotCurHogCrate
Wuzzy <Wuzzy2@mail.ru>
parents:
11046
diff
changeset

409 
(Land[y+r, xr] and lfNotCurHogCrate <> 0) or 
f1d349a52bc7
Refactor: lfCurrentHogâ†’lfCurHogCrate, lfNotCurrentMaskâ†’lfNotCurHogCrate
Wuzzy <Wuzzy2@mail.ru>
parents:
11046
diff
changeset

410 
(Land[y+r, x+r] and lfNotCurHogCrate <> 0) then 
8845
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

411 
exit(true); 
8924  412 

8845
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

413 
TestColl:= false; 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

414 
end; 
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

415 

8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

416 

2616
6e2b341dc408
AI fire w/o moving for artillery. Needs testing, but seems to work quickly and w/o AI screwups.
nemo
parents:
2599
diff
changeset

417 
// Wrapper to test various approaches. If it works reasonably, will just replace. 
6e2b341dc408
AI fire w/o moving for artillery. Needs testing, but seems to work quickly and w/o AI screwups.
nemo
parents:
2599
diff
changeset

418 
// Right now, converting to hwFloat is a tad inefficient since the x/y were hwFloat to begin with... 
6986
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6952
diff
changeset

419 
function TestCollExcludingMe(Me: PGear; x, y, r: LongInt): boolean; inline; 
2616
6e2b341dc408
AI fire w/o moving for artillery. Needs testing, but seems to work quickly and w/o AI screwups.
nemo
parents:
2599
diff
changeset

420 
var MeX, MeY: LongInt; 
6e2b341dc408
AI fire w/o moving for artillery. Needs testing, but seems to work quickly and w/o AI screwups.
nemo
parents:
2599
diff
changeset

421 
begin 
6e2b341dc408
AI fire w/o moving for artillery. Needs testing, but seems to work quickly and w/o AI screwups.
nemo
parents:
2599
diff
changeset

422 
if ((x and LAND_WIDTH_MASK) = 0) and ((y and LAND_HEIGHT_MASK) = 0) then 
6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

423 
begin 
2616
6e2b341dc408
AI fire w/o moving for artillery. Needs testing, but seems to work quickly and w/o AI screwups.
nemo
parents:
2599
diff
changeset

424 
MeX:= hwRound(Me^.X); 
6e2b341dc408
AI fire w/o moving for artillery. Needs testing, but seems to work quickly and w/o AI screwups.
nemo
parents:
2599
diff
changeset

425 
MeY:= hwRound(Me^.Y); 
6e2b341dc408
AI fire w/o moving for artillery. Needs testing, but seems to work quickly and w/o AI screwups.
nemo
parents:
2599
diff
changeset

426 
// We are still inside the hog. Skip radius test 
8845
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

427 
if ((sqr(xMeX) + sqr(yMeY)) < 256) and (Land[y, x] and lfObjMask = 0) then 
7041  428 
exit(false); 
6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

429 
end; 
8845
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jareeVirtualBox
parents:
8810
diff
changeset

430 
TestCollExcludingMe:= TestCollWithEverything(x, y, r) 
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:
7164
diff
changeset

431 
end; 
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:
7164
diff
changeset

432 

4  433 

6767
ccbf07b38a43
First pass at making AI drowning aware. No concerns of performance, only applied to bazooka (not bat/fp etc)
nemo
parents:
6766
diff
changeset

434 

8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

435 
function TraceFall(eX, eY: LongInt; var x, y: Real; dX, dY: Real; r: LongWord; Target: TTarget): LongInt; 
6767
ccbf07b38a43
First pass at making AI drowning aware. No concerns of performance, only applied to bazooka (not bat/fp etc)
nemo
parents:
6766
diff
changeset

436 
var skipLandCheck: boolean; 
8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

437 
rCorner, dxdy, odX, odY: real; 
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

438 
dmg: LongInt; 
6767
ccbf07b38a43
First pass at making AI drowning aware. No concerns of performance, only applied to bazooka (not bat/fp etc)
nemo
parents:
6766
diff
changeset

439 
begin 
8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

440 
odX:= dX; 
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

441 
odY:= dY; 
6769
44ad49a3a126
Add drowning to grenade too, try some little optimisations
nemo
parents:
6768
diff
changeset

442 
skipLandCheck:= true; 
6767
ccbf07b38a43
First pass at making AI drowning aware. No concerns of performance, only applied to bazooka (not bat/fp etc)
nemo
parents:
6766
diff
changeset

443 
// ok. attempt approximate search for an unbroken trajectory into water. if it continues far enough, assume out of map 
ccbf07b38a43
First pass at making AI drowning aware. No concerns of performance, only applied to bazooka (not bat/fp etc)
nemo
parents:
6766
diff
changeset

444 
rCorner:= r * 0.75; 
ccbf07b38a43
First pass at making AI drowning aware. No concerns of performance, only applied to bazooka (not bat/fp etc)
nemo
parents:
6766
diff
changeset

445 
while true do 
8952
a6ee1e7310fb
trying to make AI aware of mine/explosive break point. also remove redundant test.
nemo
parents:
8951
diff
changeset

446 
begin 
13668  447 
x:= CheckWrap(x); 
6767
ccbf07b38a43
First pass at making AI drowning aware. No concerns of performance, only applied to bazooka (not bat/fp etc)
nemo
parents:
6766
diff
changeset

448 
x:= x + dX; 
6768  449 
y:= y + dY; 
15690
c4d7eb75fd8a
AI: Add aiGravity and aiGravityf variables
Wuzzy <Wuzzy2@mail.ru>
parents:
15685
diff
changeset

450 
dY:= dY + aiGravityf; 
6769
44ad49a3a126
Add drowning to grenade too, try some little optimisations
nemo
parents:
6768
diff
changeset

451 
skipLandCheck:= skipLandCheck and (r <> 0) and (abs(eXx) + abs(eYy) < r) and ((abs(eXx) < rCorner) or (abs(eYy) < rCorner)); 
8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

452 
if not skipLandCheck and TestCollExcludingObjects(trunc(x), trunc(y), Target.Radius) then 
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

453 
with Target do 
8952
a6ee1e7310fb
trying to make AI aware of mine/explosive break point. also remove redundant test.
nemo
parents:
8951
diff
changeset

454 
begin 
8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

455 
if (Kind = gtHedgehog) and (0.4 < dY) then 
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

456 
begin 
8966
5ab59d79bc9a
remove redundant abs, and some incorrect 1+ to damage
nemo
parents:
8964
diff
changeset

457 
dmg := 1 + trunc((dY  0.4) * 70); 
5ab59d79bc9a
remove redundant abs, and some incorrect 1+ to damage
nemo
parents:
8964
diff
changeset

458 
exit(dmg) 
8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

459 
end 
10015  460 
else 
8952
a6ee1e7310fb
trying to make AI aware of mine/explosive break point. also remove redundant test.
nemo
parents:
8951
diff
changeset

461 
begin 
8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

462 
dxdy:= abs(dX)+abs(dY); 
10015  463 
if ((Kind = gtMine) and (dxdy > 0.35)) or 
464 
((Kind = gtExplosives) and 

8969  465 
(((State and gstTmpFlag <> 0) and (dxdy > 0.35)) or 
10015  466 
((State and gstTmpFlag = 0) and 
467 
((abs(odX) > 0.15) or ((abs(odY) > 0.15) and 

8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

468 
(abs(odX) > 0.02))) and (dxdy > 0.35)))) then 
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

469 
begin 
8966
5ab59d79bc9a
remove redundant abs, and some incorrect 1+ to damage
nemo
parents:
8964
diff
changeset

470 
dmg := trunc(dxdy * 25); 
8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

471 
exit(dmg) 
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

472 
end 
9136  473 
else if (Kind = gtExplosives) and (not(abs(odX) > 0.15) or ((abs(odY) > 0.15) and (abs(odX) > 0.02))) and (dY > 0.2) then 
8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

474 
begin 
8966
5ab59d79bc9a
remove redundant abs, and some incorrect 1+ to damage
nemo
parents:
8964
diff
changeset

475 
dmg := trunc(dy * 70); 
8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

476 
exit(dmg) 
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

477 
end 
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

478 
end; 
7041  479 
exit(0) 
8952
a6ee1e7310fb
trying to make AI aware of mine/explosive break point. also remove redundant test.
nemo
parents:
8951
diff
changeset

480 
end; 
10354  481 
if CheckCoordInWater(round(x), round(y)) then exit(1) 
8952
a6ee1e7310fb
trying to make AI aware of mine/explosive break point. also remove redundant test.
nemo
parents:
8951
diff
changeset

482 
end 
6767
ccbf07b38a43
First pass at making AI drowning aware. No concerns of performance, only applied to bazooka (not bat/fp etc)
nemo
parents:
6766
diff
changeset

483 
end; 
ccbf07b38a43
First pass at making AI drowning aware. No concerns of performance, only applied to bazooka (not bat/fp etc)
nemo
parents:
6766
diff
changeset

484 

8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

485 
function TraceShoveFall(var x, y: Real; dX, dY: Real; Target: TTarget): LongInt; 
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

486 
var dmg: LongInt; 
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

487 
dxdy, odX, odY: real; 
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

488 
begin 
8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

489 
odX:= dX; 
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

490 
odY:= dY; 
7716  491 
//v:= random($FFFFFFFF); 
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

492 
while true do 
8957
bdeb52d57dae
explosive/mine damage for shove fall. AI still seems to refuse to bat dud mines :(
nemo
parents:
8956
diff
changeset

493 
begin 
13668  494 
x:= CheckWrap(x); 
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

495 
x:= x + dX; 
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

496 
y:= y + dY; 
15690
c4d7eb75fd8a
AI: Add aiGravity and aiGravityf variables
Wuzzy <Wuzzy2@mail.ru>
parents:
15685
diff
changeset

497 
dY:= dY + aiGravityf; 
7435
bf80e66d6131
Commit commented out code which I used to debug AI walking
unc0rr
parents:
7433
diff
changeset

498 

8924  499 
{ if ((trunc(y) and LAND_HEIGHT_MASK) = 0) and ((trunc(x) and LAND_WIDTH_MASK) = 0) then 
7210
2ff30b79d2b0
 Adjust some consts so whip and firepunch work perfectly
unc0rr
parents:
7208
diff
changeset

500 
begin 
2ff30b79d2b0
 Adjust some consts so whip and firepunch work perfectly
unc0rr
parents:
7208
diff
changeset

501 
LandPixels[trunc(y), trunc(x)]:= v; 
2ff30b79d2b0
 Adjust some consts so whip and firepunch work perfectly
unc0rr
parents:
7208
diff
changeset

502 
UpdateLandTexture(trunc(X), 1, trunc(Y), 1, true); 
7435
bf80e66d6131
Commit commented out code which I used to debug AI walking
unc0rr
parents:
7433
diff
changeset

503 
end;} 
bf80e66d6131
Commit commented out code which I used to debug AI walking
unc0rr
parents:
7433
diff
changeset

504 

8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

505 
if TestCollExcludingObjects(trunc(x), trunc(y), Target.Radius) then 
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

506 
with Target do 
8957
bdeb52d57dae
explosive/mine damage for shove fall. AI still seems to refuse to bat dud mines :(
nemo
parents:
8956
diff
changeset

507 
begin 
8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

508 
if (Kind = gtHedgehog) and (0.4 < dY) then 
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

509 
begin 
8966
5ab59d79bc9a
remove redundant abs, and some incorrect 1+ to damage
nemo
parents:
8964
diff
changeset

510 
dmg := trunc((dY  0.4) * 70); 
5ab59d79bc9a
remove redundant abs, and some incorrect 1+ to damage
nemo
parents:
8964
diff
changeset

511 
exit(dmg); 
8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

512 
end 
10015  513 
else 
8957
bdeb52d57dae
explosive/mine damage for shove fall. AI still seems to refuse to bat dud mines :(
nemo
parents:
8956
diff
changeset

514 
begin 
8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

515 
dxdy:= abs(dX)+abs(dY); 
10015  516 
if ((Kind = gtMine) and (dxdy > 0.4)) or 
517 
((Kind = gtExplosives) and 

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:
8970
diff
changeset

518 
(((State and gstTmpFlag <> 0) and (dxdy > 0.4)) or 
10015  519 
((State and gstTmpFlag = 0) and 
520 
((abs(odX) > 0.15) or ((abs(odY) > 0.15) and 

8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

521 
(abs(odX) > 0.02))) and (dxdy > 0.35)))) then 
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

522 
begin 
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:
8970
diff
changeset

523 
dmg := trunc(dxdy * 50); 
8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

524 
exit(dmg) 
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

525 
end 
9136  526 
else if (Kind = gtExplosives) and (not(abs(odX) > 0.15) or ((abs(odY) > 0.15) and (abs(odX) > 0.02))) and (dY > 0.2) then 
8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

527 
begin 
8966
5ab59d79bc9a
remove redundant abs, and some incorrect 1+ to damage
nemo
parents:
8964
diff
changeset

528 
dmg := trunc(dy * 70); 
8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

529 
exit(dmg) 
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

530 
end 
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

531 
end; 
7041  532 
exit(0) 
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

533 
end; 
10354  534 
if CheckCoordInWater(round(x), round(y)) then 
6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

535 
// returning 1 for drowning so it can be considered in the Rate routine 
7041  536 
exit(1) 
6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

537 
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

538 
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

539 

8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

540 
function RateExplosion(Me: PGear; x, y, r: LongInt): LongInt; inline; 
6986
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6952
diff
changeset

541 
begin 
8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

542 
RateExplosion:= RealRateExplosion(Me, x, y, r, 0); 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

543 
ResetTargets; 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

544 
end; 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

545 
function RateExplosion(Me: PGear; x, y, r: LongInt; Flags: LongWord): LongInt; inline; 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

546 
begin 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

547 
RateExplosion:= RealRateExplosion(Me, x, y, r, Flags); 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

548 
ResetTargets; 
6986
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6952
diff
changeset

549 
end; 
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6952
diff
changeset

550 

8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

551 
function RealRateExplosion(Me: PGear; x, y, r: LongInt; Flags: LongWord): LongInt; 
8951
95dd846caf5d
only rate subs if significant. still very much need correct fall+damage esp given different knocks.
nemo
parents:
8950
diff
changeset

552 
var i, fallDmg, dmg, dmgBase, rate, subrate, erasure: LongInt; 
8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

553 
pX, pY, dX, dY: real; 
8013  554 
hadSkips: boolean; 
4  555 
begin 
13668  556 
x:= round(CheckWrap(real(x))); 
6783  557 
fallDmg:= 0; 
2695  558 
rate:= 0; 
15608
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15389
diff
changeset

559 

308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15389
diff
changeset

560 
if (Flags and afIgnoreMe) = 0 then 
15609  561 
// add our virtual position 
15608
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15389
diff
changeset

562 
with Targets.ar[Targets.Count] do 
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15389
diff
changeset

563 
begin 
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15389
diff
changeset

564 
Point.x:= hwRound(Me^.X); 
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15389
diff
changeset

565 
Point.y:= hwRound(Me^.Y); 
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15389
diff
changeset

566 
skip:= false; 
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15389
diff
changeset

567 
matters:= true; 
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15389
diff
changeset

568 
Kind:= gtHedgehog; 
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15389
diff
changeset

569 
Density:= 1; 
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15389
diff
changeset

570 
Radius:= cHHRadius; 
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15389
diff
changeset

571 
Score:=  ThinkingHH^.Health 
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15389
diff
changeset

572 
end; 
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15389
diff
changeset

573 

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

574 
// rate explosion 
7161
21a9c70b2070
Name the flags for fall tracking and indicating whether the explosion erases terrain.
nemo
parents:
7154
diff
changeset

575 
if (Flags and afErasesLand <> 0) and (GameFlags and gfSolidLand = 0) then erasure:= r 
6767
ccbf07b38a43
First pass at making AI drowning aware. No concerns of performance, only applied to bazooka (not bat/fp etc)
nemo
parents:
6766
diff
changeset

576 
else erasure:= 0; 
8013  577 

578 
hadSkips:= false; 

579 

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

580 
for i:= 0 to Targets.Count do 
8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

581 
if not Targets.ar[i].dead then 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

582 
with Targets.ar[i] do 
15608
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15389
diff
changeset

583 
if not matters then 
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15389
diff
changeset

584 
hadSkips:= true 
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15389
diff
changeset

585 
else 
8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

586 
begin 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

587 
dmg:= 0; 
8963
1a8335f0d968
Apply radius consistently. Still doesn't explain AI fail I think, although I can't run it right now.
nemo
parents:
8962
diff
changeset

588 
dmgBase:= r + Radius div 2; 
8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

589 
if abs(Point.x  x) + abs(Point.y  y) < dmgBase then 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

590 
dmg:= trunc(dmgMod * min((dmgBase  trunc(sqrt(sqr(Point.x  x)+sqr(Point.y  y)))) div 2, r)); 
5642  591 

8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

592 
if dmg > 0 then 
6767
ccbf07b38a43
First pass at making AI drowning aware. No concerns of performance, only applied to bazooka (not bat/fp etc)
nemo
parents:
6766
diff
changeset

593 
begin 
8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

594 
pX:= Point.x; 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

595 
pY:= Point.y; 
8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

596 
fallDmg:= 0; 
10635
8e8b320eefad
nil out CurrentHedgehog in FreeModule, add a test for nil'd CurrentHedgehog in DelCI since I'd still like to use DeleteGear for the other stuff it does. Move some variable initialiasations in AI Misc to hopefully avoid some uninit val errors.
nemo
parents:
10510
diff
changeset

597 
dX:= 0; 
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:
8970
diff
changeset

598 
if (Flags and afTrackFall <> 0) and (Score > 0) and (dmg < Score) then 
8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

599 
begin 
8955  600 
dX:= (0.005 * dmg + 0.01) / Density; 
8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

601 
dY:= dX; 
10015  602 
if (Kind = gtExplosives) and (State and gstTmpFlag = 0) and 
10140  603 
(((abs(dY) >= 0.15) and (abs(dX) < 0.02)) or 
8954  604 
((abs(dY) < 0.15) and (abs(dX) < 0.15))) then 
605 
dX:= 0; 

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:
8970
diff
changeset

606 

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:
8970
diff
changeset

607 
if pX  x < 0 then dX:= dX; 
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:
8970
diff
changeset

608 
if pY  y < 0 then dY:= dY; 
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:
8970
diff
changeset

609 

8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

610 
if (x and LAND_WIDTH_MASK = 0) and ((y+cHHRadius+2) and LAND_HEIGHT_MASK = 0) and 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

611 
(Land[y+cHHRadius+2, x] and lfIndestructible <> 0) then 
8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

612 
fallDmg:= trunc(TraceFall(x, y, pX, pY, dX, dY, 0, Targets.ar[i]) * dmgMod) 
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

613 
else fallDmg:= trunc(TraceFall(x, y, pX, pY, dX, dY, erasure, Targets.ar[i]) * dmgMod) 
8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

614 
end; 
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

615 
if Kind = gtHedgehog then 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

616 
begin 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

617 
if fallDmg < 0 then // drowning. score healthier hogs higher, since their death is more likely to benefit the AI 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

618 
begin 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

619 
if Score > 0 then 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

620 
inc(rate, (KillScore + Score div 10) * 1024) // Add a bit of a bonus for bigger hog drownings 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

621 
else 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

622 
dec(rate, (KillScore * friendlyfactor div 100  Score div 10) * 1024) // and more of a punishment for drowning bigger friendly hogs 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

623 
end 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

624 
else if (dmg+fallDmg) >= abs(Score) then 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

625 
begin 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

626 
dead:= true; 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

627 
Targets.reset:= true; 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

628 
if dX < 0.035 then 
8951
95dd846caf5d
only rate subs if significant. still very much need correct fall+damage esp given different knocks.
nemo
parents:
8950
diff
changeset

629 
begin 
95dd846caf5d
only rate subs if significant. still very much need correct fall+damage esp given different knocks.
nemo
parents:
8950
diff
changeset

630 
subrate:= RealRateExplosion(Me, round(pX), round(pY), 61, afErasesLand or (Flags and afTrackFall)); 
95dd846caf5d
only rate subs if significant. still very much need correct fall+damage esp given different knocks.
nemo
parents:
8950
diff
changeset

631 
if abs(subrate) > 2000 then inc(Rate,subrate) 
95dd846caf5d
only rate subs if significant. still very much need correct fall+damage esp given different knocks.
nemo
parents:
8950
diff
changeset

632 
end; 
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

633 
if Score > 0 then 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

634 
inc(rate, KillScore * 1024 + (dmg + fallDmg)) // tiny bonus for dealing more damage than needed to kill 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

635 
else dec(rate, KillScore * friendlyfactor div 100 * 1024) 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

636 
end 
8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

637 
else 
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

638 
begin 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

639 
if Score > 0 then 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

640 
inc(rate, (dmg + fallDmg) * 1024) 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

641 
else dec(rate, (dmg + fallDmg) * friendlyfactor div 100 * 1024) 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

642 
end 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

643 
end 
8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

644 
else if (fallDmg >= 0) and ((dmg+fallDmg) >= Score) then 
8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

645 
begin 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

646 
dead:= true; 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

647 
Targets.reset:= true; 
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

648 
if Kind = gtExplosives then 
8951
95dd846caf5d
only rate subs if significant. still very much need correct fall+damage esp given different knocks.
nemo
parents:
8950
diff
changeset

649 
subrate:= RealRateExplosion(Me, round(pX), round(pY), 151, afErasesLand or (Flags and afTrackFall)) 
95dd846caf5d
only rate subs if significant. still very much need correct fall+damage esp given different knocks.
nemo
parents:
8950
diff
changeset

650 
else subrate:= RealRateExplosion(Me, round(pX), round(pY), 101, afErasesLand or (Flags and afTrackFall)); 
95dd846caf5d
only rate subs if significant. still very much need correct fall+damage esp given different knocks.
nemo
parents:
8950
diff
changeset

651 
if abs(subrate) > 2000 then inc(Rate,subrate); 
8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

652 
end 
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

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

654 
end; 
8013  655 

13472
d3209e0caf12
Fix aihDoesntMatter still being attacked with air attack
Wuzzy <Wuzzy2@mail.ru>
parents:
13470
diff
changeset

656 
if hadSkips and (rate <= 0) then 
8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

657 
RealRateExplosion:= BadTurn 
13470
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13463
diff
changeset

658 
else 
8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

659 
RealRateExplosion:= rate; 
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

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

661 

8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

662 
function RateShove(Me: PGear; x, y, r, power, kick: LongInt; gdX, gdY: real; Flags: LongWord): LongInt; 
8951
95dd846caf5d
only rate subs if significant. still very much need correct fall+damage esp given different knocks.
nemo
parents:
8950
diff
changeset

663 
var i, fallDmg, dmg, rate, subrate: LongInt; 
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

664 
dX, dY, pX, pY: real; 
13470
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13463
diff
changeset

665 
hadSkips: boolean; 
79  666 
begin 
6783  667 
fallDmg:= 0; 
7210
2ff30b79d2b0
 Adjust some consts so whip and firepunch work perfectly
unc0rr
parents:
7208
diff
changeset

668 
dX:= gdX * 0.01 * kick; 
2ff30b79d2b0
 Adjust some consts so whip and firepunch work perfectly
unc0rr
parents:
7208
diff
changeset

669 
dY:= gdY * 0.01 * kick; 
2695  670 
rate:= 0; 
13470
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13463
diff
changeset

671 
hadSkips:= false; 
433  672 
for i:= 0 to Pred(Targets.Count) do 
79  673 
with Targets.ar[i] do 
8969  674 
if skip then 
675 
begin 

676 
if Flags and afSetSkip = 0 then skip:= false 

677 
end 

678 
else if matters then 

79  679 
begin 
8969  680 
dmg:= 0; 
681 
if abs(Point.x  x) + abs(Point.y  y) < r then 

682 
dmg:= r  trunc(sqrt(sqr(Point.x  x)+sqr(Point.y  y))); 

683 

684 
if dmg > 0 then 

8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

685 
begin 
8969  686 
pX:= Point.x; 
687 
pY:= Point.y2; 

688 
fallDmg:= 0; 

689 
if (Flags and afSetSkip <> 0) then skip:= true; 

9136  690 
if (not dead) and (Flags and afTrackFall <> 0) and (Score > 0) and (power < Score) then 
10015  691 
if (Kind = gtExplosives) and (State and gstTmpFlag = 0) and 
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:
8970
diff
changeset

692 
(((abs(dY) > 0.15) and (abs(dX) < 0.02)) or 
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:
8970
diff
changeset

693 
((abs(dY) < 0.15) and (abs(dX) < 0.15))) then 
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:
8970
diff
changeset

694 
fallDmg:= trunc(TraceShoveFall(pX, pY, 0, dY, Targets.ar[i]) * dmgMod) 
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:
8970
diff
changeset

695 
else 
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:
8970
diff
changeset

696 
fallDmg:= trunc(TraceShoveFall(pX, pY, dX, dY, Targets.ar[i]) * dmgMod); 
8969  697 
if Kind = gtHedgehog then 
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

698 
begin 
8969  699 
if fallDmg < 0 then // drowning. score healthier hogs higher, since their death is more likely to benefit the AI 
700 
begin 

701 
if Score > 0 then 

702 
inc(rate, KillScore + Score div 10) // Add a bit of a bonus for bigger hog drownings 

703 
else 

704 
dec(rate, KillScore * friendlyfactor div 100  Score div 10) // and more of a punishment for drowning bigger friendly hogs 

705 
end 

706 
else if power+fallDmg >= abs(Score) then 

707 
begin 

708 
dead:= true; 

709 
Targets.reset:= true; 

710 
if dX < 0.035 then 

711 
begin 

712 
subrate:= RealRateExplosion(Me, round(pX), round(pY), 61, afErasesLand or afTrackFall); 

713 
if abs(subrate) > 2000 then inc(Rate,subrate div 1024) 

714 
end; 

715 
if Score > 0 then 

716 
inc(rate, KillScore) 

717 
else 

718 
dec(rate, KillScore * friendlyfactor div 100) 

719 
end 

8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

720 
else 
8969  721 
begin 
722 
if Score > 0 then 

723 
inc(rate, power+fallDmg) 

724 
else 

725 
dec(rate, (power+fallDmg) * friendlyfactor div 100) 

726 
end 

8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

727 
end 
8969  728 
else if (fallDmg >= 0) and ((dmg+fallDmg) >= Score) then 
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

729 
begin 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

730 
dead:= true; 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

731 
Targets.reset:= true; 
8969  732 
if Kind = gtExplosives then 
733 
subrate:= RealRateExplosion(Me, round(pX), round(pY), 151, afErasesLand or (Flags and afTrackFall)) 

734 
else subrate:= RealRateExplosion(Me, round(pX), round(pY), 101, afErasesLand or (Flags and afTrackFall)); 

735 
if abs(subrate) > 2000 then inc(Rate,subrate div 1024); 

8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

736 
end 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

737 
end 
13470
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13463
diff
changeset

738 
end 
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13463
diff
changeset

739 
else 
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13463
diff
changeset

740 
hadSkips:= true; 
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13463
diff
changeset

741 

13472
d3209e0caf12
Fix aihDoesntMatter still being attacked with air attack
Wuzzy <Wuzzy2@mail.ru>
parents:
13470
diff
changeset

742 
if hadSkips and (rate <= 0) then 
13470
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13463
diff
changeset

743 
RateShove:= BadTurn 
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13463
diff
changeset

744 
else 
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13463
diff
changeset

745 
RateShove:= rate * 1024; 
8970  746 
ResetTargets 
79  747 
end; 
748 

8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

749 
function RateShotgun(Me: PGear; gdX, gdY: real; x, y: LongInt): LongInt; 
8951
95dd846caf5d
only rate subs if significant. still very much need correct fall+damage esp given different knocks.
nemo
parents:
8950
diff
changeset

750 
var i, dmg, fallDmg, baseDmg, rate, subrate, erasure: LongInt; 
8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

751 
pX, pY, dX, dY: real; 
8013  752 
hadSkips: boolean; 
509  753 
begin 
2695  754 
rate:= 0; 
6776  755 
gdX:= gdX * 0.01; 
756 
gdY:= gdX * 0.01; 

509  757 
// add our virtual position 
758 
with Targets.ar[Targets.Count] do 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

759 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

760 
Point.x:= hwRound(Me^.X); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

761 
Point.y:= hwRound(Me^.Y); 
8013  762 
skip:= false; 
763 
matters:= true; 

8960  764 
Kind:= gtHedgehog; 
8961  765 
Density:= 1; 
8963
1a8335f0d968
Apply radius consistently. Still doesn't explain AI fail I think, although I can't run it right now.
nemo
parents:
8962
diff
changeset

766 
Radius:= cHHRadius; 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

767 
Score:=  ThinkingHH^.Health 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

768 
end; 
509  769 
// rate shot 
6771  770 
baseDmg:= cHHRadius + cShotgunRadius + 4; 
8013  771 

6771  772 
if GameFlags and gfSolidLand = 0 then erasure:= cShotgunRadius 
773 
else erasure:= 0; 

8013  774 

775 
hadSkips:= false; 

776 

509  777 
for i:= 0 to Targets.Count do 
8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

778 
if not Targets.ar[i].dead then 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

779 
with Targets.ar[i] do 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

780 
if not matters then hadSkips:= true 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

781 
else 
509  782 
begin 
8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

783 
dmg:= 0; 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

784 
if abs(Point.x  x) + abs(Point.y  y) < baseDmg then 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

785 
begin 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

786 
dmg:= min(baseDmg  trunc(sqrt(sqr(Point.x  x)+sqr(Point.y  y))), 25); 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

787 
dmg:= trunc(dmg * dmgMod); 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

788 
end; 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

789 
if dmg > 0 then 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

790 
begin 
10635
8e8b320eefad
nil out CurrentHedgehog in FreeModule, add a test for nil'd CurrentHedgehog in DelCI since I'd still like to use DeleteGear for the other stuff it does. Move some variable initialiasations in AI Misc to hopefully avoid some uninit val errors.
nemo
parents:
10510
diff
changeset

791 
fallDmg:= 0; 
8e8b320eefad
nil out CurrentHedgehog in FreeModule, add a test for nil'd CurrentHedgehog in DelCI since I'd still like to use DeleteGear for the other stuff it does. Move some variable initialiasations in AI Misc to hopefully avoid some uninit val errors.
nemo
parents:
10510
diff
changeset

792 
pX:= Point.x; 
8e8b320eefad
nil out CurrentHedgehog in FreeModule, add a test for nil'd CurrentHedgehog in DelCI since I'd still like to use DeleteGear for the other stuff it does. Move some variable initialiasations in AI Misc to hopefully avoid some uninit val errors.
nemo
parents:
10510
diff
changeset

793 
pY:= Point.y; 
9136  794 
if (not dead) and (Score > 0) and (dmg < Score) then 
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:
8970
diff
changeset

795 
begin 
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:
8970
diff
changeset

796 
dX:= gdX * dmg / Density; 
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:
8970
diff
changeset

797 
dY:= gdY * dmg / Density; 
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:
8970
diff
changeset

798 
if dX < 0 then dX:= dX  0.01 
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:
8970
diff
changeset

799 
else dX:= dX + 0.01; 
10015  800 
if (Kind = gtExplosives) and (State and gstTmpFlag = 0) and 
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:
8970
diff
changeset

801 
(((abs(dY) > 0.15) and (abs(dX) < 0.02)) or 
10015  802 
((abs(dY) < 0.15) and (abs(dX) < 0.15))) then 
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:
8970
diff
changeset

803 
dX:= 0; 
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:
8970
diff
changeset

804 
if (x and LAND_WIDTH_MASK = 0) and ((y+cHHRadius+2) and LAND_HEIGHT_MASK = 0) and 
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:
8970
diff
changeset

805 
(Land[y+cHHRadius+2, x] and lfIndestructible <> 0) then 
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:
8970
diff
changeset

806 
fallDmg:= trunc(TraceFall(x, y, pX, pY, dX, dY, 0, Targets.ar[i]) * dmgMod) 
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:
8970
diff
changeset

807 
else fallDmg:= trunc(TraceFall(x, y, pX, pY, dX, dY, erasure, Targets.ar[i]) * dmgMod) 
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:
8970
diff
changeset

808 
end; 
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

809 
if Kind = gtHedgehog then 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

810 
begin 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

811 
if fallDmg < 0 then // drowning. score healthier hogs higher, since their death is more likely to benefit the AI 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

812 
begin 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

813 
if Score > 0 then 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

814 
inc(rate, KillScore + Score div 10) // Add a bit of a bonus for bigger hog drownings 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

815 
else 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

816 
dec(rate, KillScore * friendlyfactor div 100  Score div 10) // and more of a punishment for drowning bigger friendly hogs 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

817 
end 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

818 
else if (dmg+fallDmg) >= abs(Score) then 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

819 
begin 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

820 
dead:= true; 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

821 
Targets.reset:= true; 
15366  822 
if abs(gdX) < 0.035 then 
8951
95dd846caf5d
only rate subs if significant. still very much need correct fall+damage esp given different knocks.
nemo
parents:
8950
diff
changeset

823 
begin 
95dd846caf5d
only rate subs if significant. still very much need correct fall+damage esp given different knocks.
nemo
parents:
8950
diff
changeset

824 
subrate:= RealRateExplosion(Me, round(pX), round(pY), 61, afErasesLand or afTrackFall); 
95dd846caf5d
only rate subs if significant. still very much need correct fall+damage esp given different knocks.
nemo
parents:
8950
diff
changeset

825 
if abs(subrate) > 2000 then inc(Rate,subrate div 1024) 
95dd846caf5d
only rate subs if significant. still very much need correct fall+damage esp given different knocks.
nemo
parents:
8950
diff
changeset

826 
end; 
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

827 
if Score > 0 then 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

828 
inc(rate, KillScore) 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

829 
else 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

830 
dec(rate, KillScore * friendlyfactor div 100) 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

831 
end 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

832 
else if Score > 0 then 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

833 
inc(rate, dmg+fallDmg) 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

834 
else dec(rate, (dmg+fallDmg) * friendlyfactor div 100) 
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

835 
end 
8962
9780e79619ed
So. This at least should make the math more accurate, even if it still doesn't appear to resolve prob w/ AI attacks
nemo
parents:
8961
diff
changeset

836 
else if (fallDmg >= 0) and ((dmg+fallDmg) >= Score) then 
8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

837 
begin 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

838 
dead:= true; 
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

839 
Targets.reset:= true; 
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

840 
if Kind = gtExplosives then 
8951
95dd846caf5d
only rate subs if significant. still very much need correct fall+damage esp given different knocks.
nemo
parents:
8950
diff
changeset

841 
subrate:= RealRateExplosion(Me, round(pX), round(pY), 151, afErasesLand or afTrackFall) 
95dd846caf5d
only rate subs if significant. still very much need correct fall+damage esp given different knocks.
nemo
parents:
8950
diff
changeset

842 
else subrate:= RealRateExplosion(Me, round(pX), round(pY), 101, afErasesLand or afTrackFall); 
95dd846caf5d
only rate subs if significant. still very much need correct fall+damage esp given different knocks.
nemo
parents:
8950
diff
changeset

843 
if abs(subrate) > 2000 then inc(Rate,subrate div 1024); 
8939
b26aaf28c920
So. First pass. Add secondary explosions to RateExplosion and RateShotgun. Not yet added to shoves. This is of limited utility at present since the dX has to be small since we can't bother tracing all hog motion. But, should be more useful once shove is added, and tracking of explosives and mines.
nemo
parents:
8924
diff
changeset

844 
end 
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

845 
end 
509  846 
end; 
8013  847 

13472
d3209e0caf12
Fix aihDoesntMatter still being attacked with air attack
Wuzzy <Wuzzy2@mail.ru>
parents:
13470
diff
changeset

848 
if hadSkips and (rate <= 0) then 
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

849 
RateShotgun:= BadTurn 
13470
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13463
diff
changeset

850 
else 
8950
3bf81ed1f984
Make hogs aware of dud mines and explosives. Still a bit more needed.
nemo
parents:
8939
diff
changeset

851 
RateShotgun:= rate * 1024; 
13470
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13463
diff
changeset

852 
ResetTargets; 
509  853 
end; 
854 

15617  855 
function RateSeduction(Me: PGear): LongInt; 
856 
var pX, pY, i, r, rate, subrate, fallDmg: LongInt; 

857 
diffX, diffY: LongInt; 

858 
meX, meY, dX, dY: hwFloat; 

859 
pXr, pYr: real; 

860 
hadSkips: boolean; 

861 
begin 

862 
meX:= Me^.X; 

863 
meY:= Me^.Y; 

864 
rate:= 0; 

865 
for i:= 0 to Targets.Count do 

866 
if not Targets.ar[i].dead then 

867 
with Targets.ar[i] do 

868 
begin 

869 
pX:= Point.X; 

870 
pY:= Point.Y; 

871 
diffX:= pX  hwRound(meX); 

872 
diffY:= pY  hwRound(meY); 

873 
if (Me^.Hedgehog^.BotLevel < 4) and (abs(diffX) <= cHHRadius*2) and (diffY >= 0) and (diffY <= cHHRadius*2) then 

874 
// Don't use seduction if too close to other hog. We could be 

875 
// standing on it, so using seduction would remove the ground on 

876 
// which we stand on, which is dangerous 

877 
exit(BadTurn); 

878 

879 
if (not matters) then 

880 
hadSkips:= true 

881 
else if matters and (Kind = gtHedgehog) and (abs(pX  hwRound(meX)) + abs(pY  hwRound(meY)) < cSeductionDist) then 

882 
begin 

883 
r:= trunc(sqrt(sqr(abs(pX  hwRound(meX)))+sqr(abs(pY  hwRound(meY))))); 

884 
if r < cSeductionDist then 

885 
begin 

886 

887 
if (WorldEdge <> weWrap) or (not (hwAbs(meX  int2hwFloat(pX)) > int2hwFloat(cSeductionDist))) then 

15690
c4d7eb75fd8a
AI: Add aiGravity and aiGravityf variables
Wuzzy <Wuzzy2@mail.ru>
parents:
15685
diff
changeset

888 
dX:= _50 * aiGravity * (meX  int2hwFloat(pX)) / _25 
15617  889 
else if (not (hwAbs(meX + int2hwFloat((RightXLeftX)  pX)) > int2hwFloat(cSeductionDist))) then 
15690
c4d7eb75fd8a
AI: Add aiGravity and aiGravityf variables
Wuzzy <Wuzzy2@mail.ru>
parents:
15685
diff
changeset

890 
dX:= _50 * aiGravity * (meX + (int2hwFloat((RightXLeftX)  pX))) / _25 
15617  891 
else 
15690
c4d7eb75fd8a
AI: Add aiGravity and aiGravityf variables
Wuzzy <Wuzzy2@mail.ru>
parents:
15685
diff
changeset

892 
dX:= _50 * aiGravity * (meX  (int2hwFloat((RightXLeftX)  pX))) / _25; 
15617  893 
dY:= _450 * cMaxWindSpeed * 2; 
894 

895 

896 
pXr:= pX; 

897 
pYr:= pY; 

898 
fallDmg:= trunc(TraceShoveFall(pXr, pYr, hwFloat2Float(dX), hwFloat2Float(dY), Targets.ar[i]) * dmgMod); 

899 

900 
// rate damage 

901 
if fallDmg < 0 then // drowning 

902 
begin 

903 
if Score > 0 then 

904 
inc(rate, (KillScore + Score div 10) * 1024) // Add a bit of a bonus for bigger hog drownings 

905 
else 

906 
dec(rate, (KillScore * friendlyfactor div 100  Score div 10) * 1024) // and more of a punishment for drowning bigger friendly hogs 

907 
end 

908 
else if (fallDmg) >= abs(Score) then // deadly fall damage 

909 
begin 

910 
dead:= true; 

911 
Targets.reset:= true; 

912 
if (hwFloat2Float(dX) < 0.035) then 

913 
begin 

914 
subrate:= RealRateExplosion(Me, round(pX), round(pY), 61, afErasesLand or afTrackFall); // hog explodes 

915 
if abs(subrate) > 2000 then 

916 
inc(rate, subrate) 

917 
end; 

918 
if Score > 0 then 

919 
inc(rate, KillScore * 1024 + (fallDmg)) // tiny bonus for dealing more damage than needed to kill 

920 
else 

921 
dec(rate, KillScore * friendlyfactor div 100 * 1024) 

922 
end 

923 
else if (fallDmg <> 0) then // nondeadly fall damage 

924 
if Score > 0 then 

925 
inc(rate, fallDmg * 1024) 

926 
else 

927 
dec(rate, fallDmg * friendlyfactor div 100 * 1024) 

928 
else // no damage, just shoved 

929 
if (Score < 0) then 

930 
dec(rate, 100); // small penalty for shoving friendly hogs as it might be dangerous 

931 
end; 

932 
end; 

933 
end; 

934 

935 
if hadSkips and (rate <= 0) then 

936 
RateSeduction:= BadTurn 

937 
else 

938 
RateSeduction:= rate * 1024; 

939 
end; 

940 

15685  941 
function RateResurrector(Me: PGear): LongInt; 
942 
var i, r, rate, pX, pY: LongInt; 

943 
meX, meY: hwFloat; 

944 
hadSkips: boolean; 

945 
begin 

946 
meX:= Me^.X; 

947 
meY:= Me^.Y; 

948 
rate:= 0; 

949 
for i:= 0 to Targets.Count do 

950 
if (Targets.ar[i].Kind = gtGrave) and (not Targets.ar[i].dead) then 

951 
with Targets.ar[i] do 

952 
begin 

953 
pX:= Point.X; 

954 
pY:= Point.Y; 

955 

956 
if (not matters) then 

957 
hadSkips:= true 

958 
else if matters and (abs(pX  hwRound(meX)) + abs(pY  hwRound(meY)) < cResurrectorDist) then 

959 
begin 

960 
r:= trunc(sqrt(sqr(abs(pX  hwRound(meX)))+sqr(abs(pY  hwRound(meY))))); 

961 
if r < cResurrectorDist then 

962 
begin 

963 
if Score > 0 then 

964 
inc(rate, Score * 1024) 

965 
else 

966 
inc(rate, Score * friendlyFactor div 100 * 1024); 

967 
// a "dead" grave is a grave that we have resurrected 

968 
dead:= true; 

969 
Targets.reset:= true; 

970 
end; 

971 
end; 

972 
end; 

973 

974 
if hadSkips and (rate <= 0) then 

975 
RateResurrector:= BadTurn 

976 
else 

977 
RateResurrector:= rate * 1024; 

978 
end; 

979 

5645  980 
function RateHammer(Me: PGear): LongInt; 
981 
var x, y, i, r, rate: LongInt; 

13470
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13463
diff
changeset

982 
hadSkips: boolean; 
5645  983 
begin 
984 
// hammer hit shift against attecker hog is 10 

985 
x:= hwRound(Me^.X) + hwSign(Me^.dX) * 10; 

986 
y:= hwRound(Me^.Y); 

987 
rate:= 0; 

13470
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13463
diff
changeset

988 
hadSkips:= false; 
5645  989 
for i:= 0 to Pred(Targets.Count) do 
990 
with Targets.ar[i] do 

991 
// hammer hit radius is 8, shift is 10 

13470
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13463
diff
changeset

992 
if (not matters) then 
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13463
diff
changeset

993 
hadSkips:= true 
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13463
diff
changeset

994 
else if matters and (Kind = gtHedgehog) and (abs(Point.x  x) + abs(Point.y  y) < 18) then 
7279  995 
begin 
6785  996 
r:= trunc(sqrt(sqr(Point.x  x)+sqr(Point.y  y))); 
5645  997 

7279  998 
if r <= 18 then 
8924  999 
if Score > 0 then 
7279  1000 
inc(rate, Score div 3) 
1001 
else 

7285  1002 
inc(rate, Score div 3 * friendlyfactor div 100) 
7279  1003 
end; 
13470
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13463
diff
changeset

1004 

13472
d3209e0caf12
Fix aihDoesntMatter still being attacked with air attack
Wuzzy <Wuzzy2@mail.ru>
parents:
13470
diff
changeset

1005 
if hadSkips and (rate <= 0) then 
13470
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13463
diff
changeset

1006 
RateHammer:= BadTurn 
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13463
diff
changeset

1007 
else 
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13463
diff
changeset

1008 
RateHammer:= rate * 1024; 
5645  1009 
end; 
1010 

369  1011 
function HHJump(Gear: PGear; JumpType: TJumpType; var GoInfo: TGoInfo): boolean; 
371  1012 
var bX, bY: LongInt; 
80  1013 
begin 
6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1014 
HHJump:= false; 
80  1015 
GoInfo.Ticks:= 0; 
1016 
GoInfo.JumpType:= jmpNone; 

369  1017 
bX:= hwRound(Gear^.X); 
1018 
bY:= hwRound(Gear^.Y); 

80  1019 
case JumpType of 
7041  1020 
jmpNone: exit(false); 
8924  1021 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

1022 
jmpHJump: 
6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1023 
if TestCollisionYwithGear(Gear, 1) = 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

1024 
begin 
6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1025 
Gear^.dY:= _0_2; 
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1026 
SetLittle(Gear^.dX); 
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1027 
Gear^.State:= Gear^.State or gstMoving or gstHHJumping; 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

1028 
end 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

1029 
else 
7041  1030 
exit(false); 
8924  1031 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

1032 
jmpLJump: 
6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1033 
begin 
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1034 
if TestCollisionYwithGear(Gear, 1) <> 0 then 
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9137
diff
changeset

1035 
if TestCollisionXwithXYShift(Gear, _0, 2, hwSign(Gear^.dX)) = 0 then 
6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1036 
Gear^.Y:= Gear^.Y  int2hwFloat(2) 
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1037 
else 
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9137
diff
changeset

1038 
if TestCollisionXwithXYShift(Gear, _0, 1, hwSign(Gear^.dX)) = 0 then 
6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1039 
Gear^.Y:= Gear^.Y  _1; 
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9137
diff
changeset

1040 
if (TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) = 0) and 
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9137
diff
changeset

1041 
(TestCollisionYwithGear(Gear, 1) = 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

1042 
begin 
6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1043 
Gear^.dY:= _0_15; 
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1044 
Gear^.dX:= SignAs(_0_15, Gear^.dX); 
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1045 
Gear^.State:= Gear^.State or gstMoving or gstHHJumping 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

1046 
end 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

1047 
else 
7041  1048 
exit(false) 
6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1049 
end 
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1050 
end; 
2376  1051 

80  1052 
repeat 
8924  1053 
{if ((hwRound(Gear^.Y) and LAND_HEIGHT_MASK) = 0) and ((hwRound(Gear^.X) and LAND_WIDTH_MASK) = 0) then 
7435
bf80e66d6131
Commit commented out code which I used to debug AI walking
unc0rr
parents:
7433
diff
changeset

1054 
begin 
bf80e66d6131
Commit commented out code which I used to debug AI walking
unc0rr
parents:
7433
diff
changeset

1055 
LandPixels[hwRound(Gear^.Y), hwRound(Gear^.X)]:= Gear^.Hedgehog^.Team^.Clan^.Color; 
bf80e66d6131
Commit commented out code which I used to debug AI walking
unc0rr
parents:
7433
diff
changeset

1056 
UpdateLandTexture(hwRound(Gear^.X), 1, hwRound(Gear^.Y), 1, true); 
bf80e66d6131
Commit commented out code which I used to debug AI walking
unc0rr
parents:
7433
diff
changeset

1057 
end;} 
8924  1058 

10354  1059 
if CheckCoordInWater(hwRound(Gear^.X), hwRound(Gear^.Y) + cHHRadius) then 
7041  1060 
exit(false); 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

1061 
if (Gear^.State and gstMoving) <> 0 then 
6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1062 
begin 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

1063 
if (GoInfo.Ticks = 350) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

1064 
if (not (hwAbs(Gear^.dX) > cLittle)) and (Gear^.dY < _0_02) then 
6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1065 
begin 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

1066 
Gear^.dY:= _0_25; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

1067 
Gear^.dX:= SignAs(_0_02, Gear^.dX) 
6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1068 
end; 
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9137
diff
changeset

1069 
if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) <> 0 then SetLittle(Gear^.dX); 
6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1070 
Gear^.X:= Gear^.X + Gear^.dX; 
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1071 
inc(GoInfo.Ticks); 
15690
c4d7eb75fd8a
AI: Add aiGravity and aiGravityf variables
Wuzzy <Wuzzy2@mail.ru>
parents:
15685
diff
changeset

1072 
Gear^.dY:= Gear^.dY + aiGravity; 
6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1073 
if Gear^.dY > _0_4 then 
7041  1074 
exit(false); 
6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1075 
if (Gear^.dY.isNegative) and (TestCollisionYwithGear(Gear, 1) <> 0) then 
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1076 
Gear^.dY:= _0; 
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1077 
Gear^.Y:= Gear^.Y + Gear^.dY; 
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1078 
if (not Gear^.dY.isNegative) and (TestCollisionYwithGear(Gear, 1) <> 0) then 
7041  1079 
begin 
7426
55b49cc1f33a
Changes for the benefit of pas2c. Use downto in for loops to avoid repeated calls of Random/GetRandom. Wrap nots.
nemo
parents:
7385
diff
changeset

1080 
Gear^.State:= Gear^.State and (not (gstMoving or gstHHJumping)); 
6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1081 
Gear^.dY:= _0; 
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1082 
case JumpType of 
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1083 
jmpHJump: 
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1084 
if bY  hwRound(Gear^.Y) > 5 then 
7041  1085 
begin 
6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1086 
GoInfo.JumpType:= jmpHJump; 
7041  1087 
inc(GoInfo.Ticks, 300 + 300); // 300 before jump, 300 after 
1088 
exit(true) 

1089 
end; 

6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1090 
jmpLJump: 
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1091 
if abs(bX  hwRound(Gear^.X)) > 30 then 
7041  1092 
begin 
6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1093 
GoInfo.JumpType:= jmpLJump; 
7041  1094 
inc(GoInfo.Ticks, 300 + 300); // 300 before jump, 300 after 
1095 
exit(true) 

1096 
end 

1097 
end; 

1098 
exit(false) 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

1099 
end; 
6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1100 
end; 
369  1101 
until false 
80  1102 
end; 
1103 

369  1104 
function HHGo(Gear, AltGear: PGear; var GoInfo: TGoInfo): boolean; 
7375
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

1105 
var pX, pY, tY: LongInt; 
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

1106 
begin 
6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset

1107 
HHGo:= false; 
13463
f1d349a52bc7
Refactor: lfCurrentHogâ†’lfCurHogCrate, lfNotCurrentMaskâ†’lfNotCurHogCrate
Wuzzy <Wuzzy2@mail.ru>
parents:
11046
diff
changeset

1108 
Gear^.CollisionMask:= lfNotCurHogCrate; 
15389
7718bdf60d45
Set dX sign early so jump calculations always get correct value
unc0rr
parents:
15366
diff
changeset

1109 

7718bdf60d45
Set dX sign early so jump calculations always get correct value
unc0rr
parents:
15366
diff
changeset

1110 
Gear^.dX.isNegative:= (Gear^.Message and gmLeft) <> 0; 
7718bdf60d45
Set dX sign early so jump calculations always get correct value
unc0rr
parents:
15366
diff
changeset

1111 

80  1112 
AltGear^:= Gear^; 
1113 

75  1114 
GoInfo.Ticks:= 0; 
80  1115 
GoInfo.FallPix:= 0; 
1116 
GoInfo.JumpType:= jmpNone; 

7375
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

1117 
tY:= hwRound(Gear^.Y); 
4  1118 
repeat 
8924  1119 
{if ((hwRound(Gear^.Y) and LAND_HEIGHT_MASK) = 0) and ((hwRound(Gear^.X) and LAND_WIDTH_MASK) = 0) then 
7435
bf80e66d6131
Commit commented out code which I used to debug AI walking
unc0rr
parents:
7433
diff
changeset

1120 
begin 
bf80e66d6131
Commit commented out code which I used to debug AI walking
unc0rr
parents:
7433
diff
changeset

1121 
LandPixels[hwRound(Gear^.Y), hwRound(Gear^.X)]:= random($FFFFFFFF);//Gear^.Hedgehog^.Team^.Clan^.Color; 
bf80e66d6131
Commit commented out code which I used to debug AI walking
unc0rr
parents:
7433
diff
changeset

1122 
UpdateLandTexture(hwRound(Gear^.X), 1, hwRound(Gear^.Y), 1, true); 
bf80e66d6131
Commit commented out code which I used to debug AI walking
unc0rr
parents:
7433
diff
changeset

1123 
end;} 
bf80e66d6131
Commit commented out code which I used to debug AI walking
unc0rr
parents:
7433
diff
changeset

1124 

7164
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

1125 
pX:= hwRound(Gear^.X); 
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

1126 
pY:= hwRound(Gear^.Y); 
10354  1127 
if CheckCoordInWater(pX, pY + cHHRadius) then 
7375
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

1128 
begin 
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

1129 
if AltGear^.Hedgehog^.BotLevel < 4 then 
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

1130 
AddWalkBonus(pX, tY, 250, 40); 
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

1131 
exit(false) 
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

1132 
end; 
8924  1133 

1134 
// hog is falling 

7164
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

1135 
if (Gear^.State and gstMoving) <> 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

1136 
begin 
7164
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

1137 
inc(GoInfo.Ticks); 
15690
c4d7eb75fd8a
AI: Add aiGravity and aiGravityf variables
Wuzzy <Wuzzy2@mail.ru>
parents:
15685
diff
changeset

1138 
Gear^.dY:= Gear^.dY + aiGravity; 
15693
2aedd8ca836c
AI: No longer afraid of heights if invulnerable
Wuzzy <Wuzzy2@mail.ru>
parents:
15690
diff
changeset

1139 
// taking fall damage? 
2aedd8ca836c
AI: No longer afraid of heights if invulnerable
Wuzzy <Wuzzy2@mail.ru>
parents:
15690
diff
changeset

1140 
if (Gear^.dY > _0_4) and (Gear^.Hedgehog^.Effects[heInvulnerable] = 0) then 
7164
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

1141 
begin 
7433
c7fff3e61d49
 Implement AI land marks which only used to tracks visited areas on the map for now. Significantly reduces wasting of cpu time by AI checking same place several times (10x or even more in rare cases)
unc0rr
parents:
7430
diff
changeset

1142 
GoInfo.FallPix:= 0; 
7164
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

1143 
// try ljump instead of fall with damage 
8924  1144 
HHJump(AltGear, jmpLJump, GoInfo); 
7375
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

1145 
if AltGear^.Hedgehog^.BotLevel < 4 then 
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7360
diff
changeset

1146 
AddWalkBonus(pX, tY, 175, 20); 
7164
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

1147 
exit(false) 
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

1148 
end; 
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

1149 
Gear^.Y:= Gear^.Y + Gear^.dY; 
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

1150 
if hwRound(Gear^.Y) > pY then 
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

1151 
inc(GoInfo.FallPix); 
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

1152 
if TestCollisionYwithGear(Gear, 1) <> 0 then 
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

1153 
begin 
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

1154 
inc(GoInfo.Ticks, 410); 
7426
55b49cc1f33a
Changes for the benefit of pas2c. Use downto in for loops to avoid repeated calls of Random/GetRandom. Wrap nots.
nemo
parents:
7385
diff
changeset

1155 
Gear^.State:= Gear^.State and (not (gstMoving or gstHHJumping)); 
7164
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

1156 
Gear^.dY:= _0; 
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

1157 
// try ljump instead of fall 
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

1158 
HHJump(AltGear, jmpLJump, GoInfo); 
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

1159 
exit(true) 
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

1160 
end; 
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

1161 
continue 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

1162 
end; 
7719
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7716
diff
changeset

1163 

15389
7718bdf60d45
Set dX sign early so jump calculations always get correct value
unc0rr
parents:
15366
diff
changeset

1164 
// usual walk 
7718bdf60d45
Set dX sign early so jump calculations always get correct value
unc0rr
parents:
15366
diff
changeset

1165 
Gear^.dX:= SignAs(cLittle, Gear^.dX); 
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset

1166 

15389
7718bdf60d45
Set dX sign early so jump calculations always get correct value
unc0rr
parents:
15366
diff
changeset

1167 
if MakeHedgehogsStep(Gear) then 
7718bdf60d45
Set dX sign early so jump calculations always get correct value
unc0rr
parents:
15366
diff
changeset

1168 
inc(GoInfo.Ticks, cHHStepTicks); 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

1169 

15389
7718bdf60d45
Set dX sign early so jump calculations always get correct value
unc0rr
parents:
15366
diff
changeset

1170 
// we have moved for 1 px 
7718bdf60d45
Set dX sign early so jump calculations always get correct value
unc0rr
parents:
15366
diff
changeset

1171 
if (pX <> hwRound(Gear^.X)) and ((Gear^.State and gstMoving) = 0) then 
7718bdf60d45
Set dX sign early so jump calculations always get correct value
unc0rr
parents:
15366
diff
changeset

1172 
exit(true) 
542  1173 
until (pX = hwRound(Gear^.X)) and (pY = hwRound(Gear^.Y)) and ((Gear^.State and gstMoving) = 0); 
7164
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7161
diff
changeset

1174 

375  1175 
HHJump(AltGear, jmpHJump, GoInfo); 
4  1176 
end; 
1177 

14212
ca179b615c0b
adding X offset seems to improve chance of drownings
nemo
parents:
13668
diff
changeset

1178 
function AIrndSign(num: LongInt): LongInt; inline; 
136  1179 
begin 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

1180 
if random(2) = 0 then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

1181 
AIrndSign:= num 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

1182 
else 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset

1183 
AIrndSign:=  num 
2376  1184 
end; 
136  1185 

14212
ca179b615c0b
adding X offset seems to improve chance of drownings
nemo
parents:
13668
diff
changeset

1186 
function AIrndOffset(targ: TTarget; Level: LongWord): LongInt; inline; 
ca179b615c0b
adding X offset seems to improve chance of drownings
nemo
parents:
13668
diff
changeset

1187 
begin 
ca179b615c0b
adding X offset seems to improve chance of drownings
nemo
parents:
13668
diff
changeset

1188 
if Level <> 1 then exit(0); 
ca179b615c0b
adding X offset seems to improve chance of drownings
nemo
parents:
13668
diff
changeset

1189 
// at present level 2 doesn't track falls on most things 
ca179b615c0b
adding X offset seems to improve chance of drownings
nemo
parents:
13668
diff
changeset

1190 
//if Level = 2 then exit(round(targ.Radius*(random(5)2)/2)); 
14213  1191 
AIrndOffset := targ.Radius*(random(7)3)*2 
14212
ca179b615c0b
adding X offset seems to improve chance of drownings
nemo
parents:
13668
diff
changeset

1192 
end; 
ca179b615c0b
adding X offset seems to improve chance of drownings
nemo
parents:
13668
diff
changeset

1193 

3038  1194 
procedure initModule; 
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset

1195 
begin 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2716
diff
changeset

1196 
friendlyfactor:= 300; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2716
diff
changeset

1197 
KnownExplosion.X:= 0; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2716
diff
changeset

1198 
KnownExplosion.Y:= 0; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2716
diff
changeset

1199 
KnownExplosion.Radius:= 0; 
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset

1200 
end; 
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset

1201 

3038  1202 
procedure freeModule; 
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset

1203 
begin 
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset

1204 
end; 
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset

1205 

4  1206 
end. 