author | Wuzzy <Wuzzy2@mail.ru> |
Wed, 08 Jul 2020 18:45:21 +0200 | |
changeset 15725 | 8111e2505a48 |
parent 15715 | 2aedd8ca836c |
child 15748 | 12973ea952c6 |
permissions | -rw-r--r-- |
71 | 1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
11046 | 3 |
* Copyright (c) 2004-2015 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 02110-1301 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; |
15631
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15410
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; |
15387 | 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; |
15640 | 90 |
function RateSeduction(Me: PGear): LongInt; |
15707 | 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; |
14233
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; |
15707 | 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 |
15712
c4d7eb75fd8a
AI: Add aiGravity and aiGravityf variables
Wuzzy <Wuzzy2@mail.ru>
parents:
15707
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 mine-heavy 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 mine-heavy 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 mine-heavy 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 mine-heavy 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 mine-heavy map.
nemo
parents:
8955
diff
changeset
|
140 |
(Gear^.Health > Gear^.Damage) and |
9136 | 141 |
(not Gear^.Hedgehog^.Team^.hasgone)) or |
15707 | 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 mine-heavy 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 mine-heavy 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 mine-heavy 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 mine-heavy 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 mine-heavy 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 mine-heavy 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 mine-heavy 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 mine-heavy 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 mine-heavy 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 mine-heavy 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 mine-heavy 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 |
15707 | 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 mine-heavy 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 mine-heavy map.
nemo
parents:
8955
diff
changeset
|
191 |
Score:= max(0,35-Gear^.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 mine-heavy 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 |
14528 | 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: |
14285 | 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 |
|
14785
b3fa6a19fc25
Computer hog no longer walks into player-placed mines if >= 90% duds
Wuzzy <Wuzzy2@mail.ru>
parents:
14607
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; |
14606 | 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) // hedgehog-friend |
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(gX-X)+abs(gY-Y) < 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@jaree-VirtualBox
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@jaree-VirtualBox
parents:
8810
diff
changeset
|
366 |
begin |
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
parents:
8810
diff
changeset
|
367 |
CheckBounds := (((x-r) and LAND_WIDTH_MASK) = 0) and |
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
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@jaree-VirtualBox
parents:
8810
diff
changeset
|
369 |
(((y-r) and LAND_HEIGHT_MASK) = 0) and |
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
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@jaree-VirtualBox
parents:
8810
diff
changeset
|
371 |
end; |
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
parents:
8810
diff
changeset
|
372 |
|
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
parents:
8810
diff
changeset
|
373 |
|
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
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@jaree-VirtualBox
parents:
8810
diff
changeset
|
375 |
begin |
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
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@jaree-VirtualBox
parents:
8810
diff
changeset
|
377 |
exit(false); |
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
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[y-r, 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
|
380 |
(Land[y+r, 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
|
381 |
(Land[y-r, 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@jaree-VirtualBox
parents:
8810
diff
changeset
|
383 |
exit(true); |
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
parents:
8810
diff
changeset
|
384 |
|
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
parents:
8810
diff
changeset
|
385 |
TestCollWithEverything := false; |
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
parents:
8810
diff
changeset
|
386 |
end; |
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
parents:
8810
diff
changeset
|
387 |
|
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
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@jaree-VirtualBox
parents:
8810
diff
changeset
|
389 |
begin |
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
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@jaree-VirtualBox
parents:
8810
diff
changeset
|
391 |
exit(false); |
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
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[y-r, x-r] > 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, x-r] > 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[y-r, x-r] > 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@jaree-VirtualBox
parents:
8810
diff
changeset
|
397 |
exit(true); |
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
parents:
8810
diff
changeset
|
398 |
|
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
parents:
8810
diff
changeset
|
399 |
TestCollExcludingObjects:= false; |
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
parents:
8810
diff
changeset
|
400 |
end; |
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
parents:
8810
diff
changeset
|
401 |
|
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
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@jaree-VirtualBox
parents:
8810
diff
changeset
|
403 |
begin |
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
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@jaree-VirtualBox
parents:
8810
diff
changeset
|
405 |
exit(false); |
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
parents:
8810
diff
changeset
|
406 |
|
13469
f1d349a52bc7
Refactor: lfCurrentHog→lfCurHogCrate, lfNotCurrentMask→lfNotCurHogCrate
Wuzzy <Wuzzy2@mail.ru>
parents:
11046
diff
changeset
|
407 |
if (Land[y-r, x-r] and lfNotCurHogCrate <> 0) or |
f1d349a52bc7
Refactor: lfCurrentHog→lfCurHogCrate, lfNotCurrentMask→lfNotCurHogCrate
Wuzzy <Wuzzy2@mail.ru>
parents:
11046
diff
changeset
|
408 |
(Land[y+r, x-r] and lfNotCurHogCrate <> 0) or |
f1d349a52bc7
Refactor: lfCurrentHog→lfCurHogCrate, lfNotCurrentMask→lfNotCurHogCrate
Wuzzy <Wuzzy2@mail.ru>
parents:
11046
diff
changeset
|
409 |
(Land[y+r, x-r] 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@jaree-VirtualBox
parents:
8810
diff
changeset
|
411 |
exit(true); |
8924 | 412 |
|
8845
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
parents:
8810
diff
changeset
|
413 |
TestColl:= false; |
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
parents:
8810
diff
changeset
|
414 |
end; |
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
parents:
8810
diff
changeset
|
415 |
|
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
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 pascal-ish 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@jaree-VirtualBox
parents:
8810
diff
changeset
|
427 |
if ((sqr(x-MeX) + sqr(y-MeY)) < 256) and (Land[y, x] and lfObjMask = 0) then |
7041 | 428 |
exit(false); |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset
|
429 |
end; |
8845
8cf1ed3bae45
Fix AI collision detection with crates and overlapping hedgehogs. Remove duplicating code
jaree@jaree-VirtualBox
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; |
15712
c4d7eb75fd8a
AI: Add aiGravity and aiGravityf variables
Wuzzy <Wuzzy2@mail.ru>
parents:
15707
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(eX-x) + abs(eY-y) < r) and ((abs(eX-x) < rCorner) or (abs(eY-y) < 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; |
15712
c4d7eb75fd8a
AI: Add aiGravity and aiGravityf variables
Wuzzy <Wuzzy2@mail.ru>
parents:
15707
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 pascal-ish 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 pascal-ish 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; |
15631
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15410
diff
changeset
|
559 |
|
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15410
diff
changeset
|
560 |
if (Flags and afIgnoreMe) = 0 then |
15632 | 561 |
// add our virtual position |
15631
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15410
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:
15410
diff
changeset
|
563 |
begin |
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15410
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:
15410
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:
15410
diff
changeset
|
566 |
skip:= false; |
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15410
diff
changeset
|
567 |
matters:= true; |
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15410
diff
changeset
|
568 |
Kind:= gtHedgehog; |
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15410
diff
changeset
|
569 |
Density:= 1; |
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15410
diff
changeset
|
570 |
Radius:= cHHRadius; |
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15410
diff
changeset
|
571 |
Score:= - ThinkingHH^.Health |
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15410
diff
changeset
|
572 |
end; |
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15410
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 |
15631
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15410
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:
15410
diff
changeset
|
584 |
hadSkips:= true |
308930fe5f4a
AI: Remove own gear from explosion/shove checks in kami/piano test
Wuzzy <Wuzzy2@mail.ru>
parents:
15410
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 |
|
13478
d3209e0caf12
Fix aihDoesntMatter still being attacked with air attack
Wuzzy <Wuzzy2@mail.ru>
parents:
13476
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 |
13476
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13469
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; |
13476
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13469
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; |
13476
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13469
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.y-2; |
|
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 |
13476
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13469
diff
changeset
|
738 |
end |
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13469
diff
changeset
|
739 |
else |
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13469
diff
changeset
|
740 |
hadSkips:= true; |
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13469
diff
changeset
|
741 |
|
13478
d3209e0caf12
Fix aihDoesntMatter still being attacked with air attack
Wuzzy <Wuzzy2@mail.ru>
parents:
13476
diff
changeset
|
742 |
if hadSkips and (rate <= 0) then |
13476
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13469
diff
changeset
|
743 |
RateShove:= BadTurn |
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13469
diff
changeset
|
744 |
else |
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13469
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; |
15387 | 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 |
|
13478
d3209e0caf12
Fix aihDoesntMatter still being attacked with air attack
Wuzzy <Wuzzy2@mail.ru>
parents:
13476
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 |
13476
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13469
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; |
13476
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13469
diff
changeset
|
852 |
ResetTargets; |
509 | 853 |
end; |
854 |
||
15640 | 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 |
|
15712
c4d7eb75fd8a
AI: Add aiGravity and aiGravityf variables
Wuzzy <Wuzzy2@mail.ru>
parents:
15707
diff
changeset
|
888 |
dX:= _50 * aiGravity * (meX - int2hwFloat(pX)) / _25 |
15640 | 889 |
else if (not (hwAbs(meX + int2hwFloat((RightX-LeftX) - pX)) > int2hwFloat(cSeductionDist))) then |
15712
c4d7eb75fd8a
AI: Add aiGravity and aiGravityf variables
Wuzzy <Wuzzy2@mail.ru>
parents:
15707
diff
changeset
|
890 |
dX:= _50 * aiGravity * (meX + (int2hwFloat((RightX-LeftX) - pX))) / _25 |
15640 | 891 |
else |
15712
c4d7eb75fd8a
AI: Add aiGravity and aiGravityf variables
Wuzzy <Wuzzy2@mail.ru>
parents:
15707
diff
changeset
|
892 |
dX:= _50 * aiGravity * (meX - (int2hwFloat((RightX-LeftX) - pX))) / _25; |
15640 | 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 // non-deadly 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 |
||
15707 | 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; |
|
13476
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13469
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; |
|
13476
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13469
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 |
|
13476
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13469
diff
changeset
|
992 |
if (not matters) then |
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13469
diff
changeset
|
993 |
hadSkips:= true |
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13469
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; |
13476
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13469
diff
changeset
|
1004 |
|
13478
d3209e0caf12
Fix aihDoesntMatter still being attacked with air attack
Wuzzy <Wuzzy2@mail.ru>
parents:
13476
diff
changeset
|
1005 |
if hadSkips and (rate <= 0) then |
13476
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13469
diff
changeset
|
1006 |
RateHammer:= BadTurn |
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13469
diff
changeset
|
1007 |
else |
0d27f0c21b71
Fix aihDoesntMatter not applying to hammer and shover
Wuzzy <Wuzzy2@mail.ru>
parents:
13469
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 pascal-ish 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 pascal-ish 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 pascal-ish 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 pascal-ish 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 pascal-ish 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 pascal-ish 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 pascal-ish 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 pascal-ish 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 pascal-ish 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 pascal-ish 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 pascal-ish 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 pascal-ish 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 pascal-ish 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 pascal-ish 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 pascal-ish 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 pascal-ish 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 pascal-ish 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 pascal-ish 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 pascal-ish 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 pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset
|
1071 |
inc(GoInfo.Ticks); |
15712
c4d7eb75fd8a
AI: Add aiGravity and aiGravityf variables
Wuzzy <Wuzzy2@mail.ru>
parents:
15707
diff
changeset
|
1072 |
Gear^.dY:= Gear^.dY + aiGravity; |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset
|
1073 |
if Gear^.dY > _0_4 then |
7041 | 1074 |
exit(false); |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset
|
1075 |
if (Gear^.dY.isNegative) and (TestCollisionYwithGear(Gear, -1) <> 0) then |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset
|
1076 |
Gear^.dY:= _0; |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset
|
1077 |
Gear^.Y:= Gear^.Y + Gear^.dY; |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
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 pascal-ish 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 pascal-ish 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 pascal-ish 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 pascal-ish 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 pascal-ish 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 pascal-ish 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 pascal-ish 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 pascal-ish 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 pascal-ish 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 pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset
|
1107 |
HHGo:= false; |
13469
f1d349a52bc7
Refactor: lfCurrentHog→lfCurHogCrate, lfNotCurrentMask→lfNotCurHogCrate
Wuzzy <Wuzzy2@mail.ru>
parents:
11046
diff
changeset
|
1108 |
Gear^.CollisionMask:= lfNotCurHogCrate; |
15410
7718bdf60d45
Set dX sign early so jump calculations always get correct value
unc0rr
parents:
15387
diff
changeset
|
1109 |
|
7718bdf60d45
Set dX sign early so jump calculations always get correct value
unc0rr
parents:
15387
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:
15387
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); |
15712
c4d7eb75fd8a
AI: Add aiGravity and aiGravityf variables
Wuzzy <Wuzzy2@mail.ru>
parents:
15707
diff
changeset
|
1138 |
Gear^.dY:= Gear^.dY + aiGravity; |
15715
2aedd8ca836c
AI: No longer afraid of heights if invulnerable
Wuzzy <Wuzzy2@mail.ru>
parents:
15712
diff
changeset
|
1139 |
// taking fall damage? |
2aedd8ca836c
AI: No longer afraid of heights if invulnerable
Wuzzy <Wuzzy2@mail.ru>
parents:
15712
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 |
|
15410
7718bdf60d45
Set dX sign early so jump calculations always get correct value
unc0rr
parents:
15387
diff
changeset
|
1164 |
// usual walk |
7718bdf60d45
Set dX sign early so jump calculations always get correct value
unc0rr
parents:
15387
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 |
|
15410
7718bdf60d45
Set dX sign early so jump calculations always get correct value
unc0rr
parents:
15387
diff
changeset
|
1167 |
if MakeHedgehogsStep(Gear) then |
7718bdf60d45
Set dX sign early so jump calculations always get correct value
unc0rr
parents:
15387
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 |
|
15410
7718bdf60d45
Set dX sign early so jump calculations always get correct value
unc0rr
parents:
15387
diff
changeset
|
1170 |
// we have moved for 1 px |
7718bdf60d45
Set dX sign early so jump calculations always get correct value
unc0rr
parents:
15387
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:
15387
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 |
||
14233
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 |
|
14233
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)); |
14234 | 1191 |
AIrndOffset := targ.Radius*(random(7)-3)*2 |
14233
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. |