author | unc0rr |
Thu, 19 Apr 2012 23:36:20 +0400 | |
changeset 6893 | 69cc0166be8d |
parent 6888 | 32a54322d262 |
child 6952 | 7f70f37bbf08 |
permissions | -rw-r--r-- |
71 | 1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
6700 | 3 |
* Copyright (c) 2005-2012 Andrey Korotaev <unC0Rr@gmail.com> |
71 | 4 |
* |
183 | 5 |
* This program is free software; you can redistribute it and/or modify |
6 |
* it under the terms of the GNU General Public License as published by |
|
7 |
* the Free Software Foundation; version 2 of the License |
|
71 | 8 |
* |
183 | 9 |
* This program is distributed in the hope that it will be useful, |
10 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
11 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
12 |
* GNU General Public License for more details. |
|
71 | 13 |
* |
183 | 14 |
* You should have received a copy of the GNU General Public License |
15 |
* along with this program; if not, write to the Free Software |
|
16 |
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA |
|
71 | 17 |
*) |
18 |
||
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; |
26 |
||
64 | 27 |
type TTarget = record |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
28 |
Point: TPoint; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
29 |
Score: LongInt; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
30 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
31 |
TTargets = record |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
32 |
Count: Longword; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
33 |
ar: array[0..Pred(cMaxHHs)] of TTarget; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
34 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
35 |
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
|
36 |
TGoInfo = record |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
37 |
Ticks: Longword; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
38 |
FallPix: Longword; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
39 |
JumpType: TJumpType; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
40 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
41 |
TBonus = record |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
42 |
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
|
43 |
Radius: LongInt; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
44 |
Score: LongInt; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
45 |
end; |
64 | 46 |
|
3038 | 47 |
procedure initModule; |
48 |
procedure freeModule; |
|
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset
|
49 |
|
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
50 |
procedure FillTargets; |
6888 | 51 |
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
|
52 |
procedure AwareOfExplosion(x, y, r: LongInt); inline; |
371 | 53 |
function RatePlace(Gear: PGear): 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
|
54 |
function TestCollExcludingMe(Me: PGear; x, y, r: LongInt): boolean; inline; |
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
|
55 |
function TestColl(x, y, r: LongInt): boolean; inline; |
6783 | 56 |
function TraceShoveFall(Me: PGear; x, y, dX, dY: Real): 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
|
57 |
function RateExplosion(Me: PGear; x, y, r: LongInt; Flags: LongWord = 0): LongInt; |
6770
7d2c6cdb816a
Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents:
6769
diff
changeset
|
58 |
function RateShove(Me: PGear; x, y, r, power, kick: LongInt; gdX, gdY: real; Flags: LongWord): LongInt; |
6771 | 59 |
function RateShotgun(Me: PGear; gdX, gdY: real; x, y: LongInt): LongInt; |
5645 | 60 |
function RateHammer(Me: PGear): LongInt; |
369 | 61 |
function HHGo(Gear, AltGear: PGear; var GoInfo: TGoInfo): boolean; |
371 | 62 |
function AIrndSign(num: LongInt): LongInt; |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
63 |
|
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
64 |
var ThinkingHH: PGear; |
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
65 |
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
|
66 |
|
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset
|
67 |
bonuses: record |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
68 |
Count: Longword; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
69 |
ar: array[0..Pred(MAXBONUS)] of TBonus; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
70 |
end; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset
|
71 |
|
3370 | 72 |
implementation |
4403 | 73 |
uses uCollisions, uVariables, uUtils, uDebug; |
3370 | 74 |
|
75 |
const KillScore = 200; |
|
76 |
||
77 |
var friendlyfactor: LongInt = 300; |
|
78 |
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
|
79 |
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
|
80 |
end = (X: 0; Y: 0; Radius: 0); |
4 | 81 |
|
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
82 |
procedure FillTargets; |
547 | 83 |
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
|
84 |
f, e: LongInt; |
4 | 85 |
begin |
86 |
Targets.Count:= 0; |
|
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
|
87 |
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
|
88 |
e:= 0; |
547 | 89 |
for t:= 0 to Pred(TeamsCount) do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
90 |
with TeamsArray[t]^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
91 |
if not hasGone then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
92 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
93 |
for i:= 0 to cMaxHHIndex do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
94 |
if (Hedgehogs[i].Gear <> nil) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
95 |
and (Hedgehogs[i].Gear <> ThinkingHH) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
96 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
97 |
with Targets.ar[Targets.Count], Hedgehogs[i] do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
98 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
99 |
Point.X:= hwRound(Gear^.X); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
100 |
Point.Y:= hwRound(Gear^.Y); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
101 |
if Clan <> CurrentTeam^.Clan then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
102 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
103 |
Score:= Gear^.Health; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
104 |
inc(e) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
105 |
end else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
106 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
107 |
Score:= -Gear^.Health; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
108 |
inc(f) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
109 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
110 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
111 |
inc(Targets.Count) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
112 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
113 |
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
|
114 |
|
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
|
115 |
if e > f then friendlyfactor:= 300 + (e - f) * 30 |
5881 | 116 |
else friendlyfactor:= max(30, 300 - f * 80 div max(1,e)) |
4 | 117 |
end; |
118 |
||
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
|
119 |
procedure AddBonus(x, y: LongInt; r: Longword; s: LongInt); inline; |
6474
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6396
diff
changeset
|
120 |
begin |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6396
diff
changeset
|
121 |
bonuses.ar[bonuses.Count].x:= x; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6396
diff
changeset
|
122 |
bonuses.ar[bonuses.Count].y:= y; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6396
diff
changeset
|
123 |
bonuses.ar[bonuses.Count].Radius:= r; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6396
diff
changeset
|
124 |
bonuses.ar[bonuses.Count].Score:= s; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6396
diff
changeset
|
125 |
inc(bonuses.Count); |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6396
diff
changeset
|
126 |
TryDo(bonuses.Count <= MAXBONUS, 'Bonuses overflow', true) |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6396
diff
changeset
|
127 |
end; |
42e9773eedfd
- Improve renderer a bit, disallow nested functions
unc0rr
parents:
6396
diff
changeset
|
128 |
|
6888 | 129 |
procedure FillBonuses(isAfterAttack: boolean); |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
130 |
var Gear: PGear; |
549 | 131 |
MyClan: PClan; |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
132 |
begin |
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
133 |
bonuses.Count:= 0; |
4372 | 134 |
MyClan:= ThinkingHH^.Hedgehog^.Team^.Clan; |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
135 |
Gear:= GearsList; |
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
136 |
while Gear <> nil do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
137 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
138 |
case Gear^.Kind of |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
139 |
gtCase: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
140 |
AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y), 33, 25); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
141 |
gtFlame: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
142 |
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
|
143 |
AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y), 20, -50); |
4977
c89cca0a8785
Try to make AI aware of dud mines by clearing gstAttacking on dud, and adding some rules on mine health/damage/dud probability to AI weighting.
nemo
parents:
4976
diff
changeset
|
144 |
// avoid mines unless they are very likely to be duds, or are duds. also avoid if they are about to blow |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
145 |
gtMine: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
146 |
if ((Gear^.State and gstAttacking) = 0) and (((cMineDudPercent < 90) and (Gear^.Health <> 0)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
147 |
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
|
148 |
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
|
149 |
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
|
150 |
AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y), 100, -50); // mine is on |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
151 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
152 |
gtExplosives: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
153 |
if isAfterAttack then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
154 |
AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y), 75, -60+Gear^.Health); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
155 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
156 |
gtSMine: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
157 |
AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y), 50, -30); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
158 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
159 |
gtDynamite: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
160 |
AddBonus(hwRound(Gear^.X), hwRound(Gear^.Y), 150, -75); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
161 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
162 |
gtHedgehog: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
163 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
164 |
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
|
165 |
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
|
166 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
167 |
if isAfterAttack and (ThinkingHH^.Hedgehog <> Gear^.Hedgehog) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
168 |
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
|
169 |
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
|
170 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
171 |
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
|
172 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
173 |
end; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
174 |
Gear:= Gear^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
175 |
end; |
71 | 176 |
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
|
177 |
with KnownExplosion do |
74 | 178 |
AddBonus(X, Y, Radius + 10, -Radius); |
71 | 179 |
end; |
180 |
||
371 | 181 |
procedure AwareOfExplosion(x, y, r: LongInt); |
71 | 182 |
begin |
183 |
KnownExplosion.X:= x; |
|
184 |
KnownExplosion.Y:= y; |
|
185 |
KnownExplosion.Radius:= r |
|
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
186 |
end; |
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
187 |
|
371 | 188 |
function RatePlace(Gear: PGear): LongInt; |
189 |
var i, r: LongInt; |
|
2695 | 190 |
rate: LongInt; |
6778 | 191 |
gX, gY: real; |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
192 |
begin |
6778 | 193 |
gX:= hwFloat2Float(Gear^.X); |
194 |
gY:= hwFloat2Float(Gear^.Y); |
|
2695 | 195 |
rate:= 0; |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
196 |
for i:= 0 to Pred(bonuses.Count) do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
197 |
with bonuses.ar[i] do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
198 |
begin |
6778 | 199 |
r:= Radius; |
200 |
if abs(gX-X)+abs(gY-Y) < Radius then |
|
201 |
r:= trunc(sqrt(sqr(gX - X)+sqr(gY - Y))); |
|
6777
fb71556205f4
Avoid local rate minimums around hog (within 15 pixels). Not tested.
unc0rr
parents:
6776
diff
changeset
|
202 |
if r < 15 then |
fb71556205f4
Avoid local rate minimums around hog (within 15 pixels). Not tested.
unc0rr
parents:
6776
diff
changeset
|
203 |
inc(rate, Score * Radius) |
fb71556205f4
Avoid local rate minimums around hog (within 15 pixels). Not tested.
unc0rr
parents:
6776
diff
changeset
|
204 |
else if r < Radius then |
fb71556205f4
Avoid local rate minimums around hog (within 15 pixels). Not tested.
unc0rr
parents:
6776
diff
changeset
|
205 |
inc(rate, Score * (Radius - r)) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
206 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
207 |
RatePlace:= rate; |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
208 |
end; |
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
209 |
|
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
|
210 |
// 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
|
211 |
// Right now, converting to hwFloat is a tad inefficient since the x/y were hwFloat to begin with... |
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
|
212 |
function TestCollExcludingMe(Me: PGear; x, y, r: LongInt): boolean; |
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
|
213 |
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
|
214 |
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
|
215 |
if ((x and LAND_WIDTH_MASK) = 0) and ((y and LAND_HEIGHT_MASK) = 0) then |
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
|
216 |
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
|
217 |
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
|
218 |
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
|
219 |
// We are still inside the hog. Skip radius test |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
220 |
if ((((x-MeX)*(x-MeX)) + ((y-MeY)*(y-MeY))) < 256) and ((Land[y, x] and $FF00) = 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
221 |
exit(false); |
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
|
222 |
end; |
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
|
223 |
exit(TestColl(x, y, r)) |
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
|
224 |
end; |
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
|
225 |
|
371 | 226 |
function TestColl(x, y, r: LongInt): boolean; |
369 | 227 |
var b: boolean; |
4 | 228 |
begin |
1753 | 229 |
b:= (((x-r) and LAND_WIDTH_MASK) = 0)and(((y-r) and LAND_HEIGHT_MASK) = 0) and (Land[y-r, x-r] <> 0); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
230 |
if b then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
231 |
exit(true); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
232 |
|
1753 | 233 |
b:=(((x-r) and LAND_WIDTH_MASK) = 0)and(((y+r) and LAND_HEIGHT_MASK) = 0) and (Land[y+r, x-r] <> 0); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
234 |
if b then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
235 |
exit(true); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
236 |
|
1753 | 237 |
b:=(((x+r) and LAND_WIDTH_MASK) = 0)and(((y-r) and LAND_HEIGHT_MASK) = 0) and (Land[y-r, x+r] <> 0); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
238 |
if b then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
239 |
exit(true); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
240 |
|
1753 | 241 |
TestColl:=(((x+r) and LAND_WIDTH_MASK) = 0)and(((y+r) and LAND_HEIGHT_MASK) = 0) and (Land[y+r, x+r] <> 0) |
4 | 242 |
end; |
243 |
||
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
|
244 |
function TestCollWithLand(x, y, r: LongInt): boolean; inline; |
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
|
245 |
var b: boolean; |
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
|
246 |
begin |
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
|
247 |
b:= (((x-r) and LAND_WIDTH_MASK) = 0)and(((y-r) and LAND_HEIGHT_MASK) = 0) and (Land[y-r, x-r] > 255); |
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
|
248 |
if b then |
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
|
249 |
exit(true); |
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
|
250 |
|
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
|
251 |
b:=(((x-r) and LAND_WIDTH_MASK) = 0)and(((y+r) and LAND_HEIGHT_MASK) = 0) and (Land[y+r, x-r] > 255); |
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
|
252 |
if b then |
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
|
253 |
exit(true); |
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
|
254 |
|
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
|
255 |
b:=(((x+r) and LAND_WIDTH_MASK) = 0)and(((y-r) and LAND_HEIGHT_MASK) = 0) and (Land[y-r, x+r] > 255); |
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
|
256 |
if b then |
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
|
257 |
exit(true); |
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
|
258 |
|
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
|
259 |
TestCollWithLand:=(((x+r) and LAND_WIDTH_MASK) = 0) and (((y+r) and LAND_HEIGHT_MASK) = 0) and (Land[y+r, x+r] > 255) |
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
|
260 |
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
|
261 |
|
6783 | 262 |
function TraceFall(eX, eY: LongInt; x, y, dX, dY: Real; r: LongWord): 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
|
263 |
var skipLandCheck: boolean; |
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
|
264 |
rCorner: real; |
6783 | 265 |
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
|
266 |
begin |
6769
44ad49a3a126
Add drowning to grenade too, try some little optimisations
nemo
parents:
6768
diff
changeset
|
267 |
skipLandCheck:= true; |
6776 | 268 |
if x - eX < 0 then dX:= -dX; |
269 |
if y - eY < 0 then dY:= -dY; |
|
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
|
270 |
// 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
|
271 |
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
|
272 |
while true do |
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
|
273 |
begin |
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
|
274 |
x:= x + dX; |
6768 | 275 |
y:= y + dY; |
276 |
dY:= dY + cGravityf; |
|
6769
44ad49a3a126
Add drowning to grenade too, try some little optimisations
nemo
parents:
6768
diff
changeset
|
277 |
skipLandCheck:= skipLandCheck and (r <> 0) and (abs(eX-x) + abs(eY-y) < r) and ((abs(eX-x) < rCorner) or (abs(eY-y) < rCorner)); |
6783 | 278 |
if not skipLandCheck and TestCollWithLand(trunc(x), trunc(y), cHHRadius) then |
279 |
begin |
|
280 |
if 0.4 < dY then |
|
281 |
begin |
|
282 |
dmg := 1 + trunc((abs(dY) - 0.4) * 70); |
|
283 |
if dmg >= 1 then exit(dmg) |
|
284 |
end; |
|
285 |
exit(0) |
|
286 |
end; |
|
287 |
if (y > cWaterLine) or (x > 4096) or (x < 0) then exit(-1); // returning -1 for drowning so it can be considered in the Rate routine |
|
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
|
288 |
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
|
289 |
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
|
290 |
|
6783 | 291 |
function TraceShoveFall(Me: PGear; x, y, dX, dY: Real): LongInt; |
292 |
var dmg: LongInt; |
|
6770
7d2c6cdb816a
Start on adding drowning bonus to bat/firepunch/whip. AI still is not smart enough to change direction when firepunching to face the water, or change the angle of the bat.
nemo
parents:
6769
diff
changeset
|
293 |
begin |
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
|
294 |
while true do |
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
|
295 |
begin |
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
|
296 |
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
|
297 |
y:= y + dY; |
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
|
298 |
dY:= dY + cGravityf; |
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
|
299 |
// consider adding dX/dY calc here for fall damage |
6783 | 300 |
if TestCollExcludingMe(Me, trunc(x), trunc(y), cHHRadius) then |
301 |
begin |
|
302 |
if 0.4 < dY then |
|
303 |
begin |
|
304 |
dmg := 1 + trunc((abs(dY) - 0.4) * 70); |
|
305 |
if dmg >= 1 then exit(dmg) |
|
306 |
end; |
|
307 |
exit(0) |
|
308 |
end; |
|
309 |
if (y > cWaterLine) or (x > 4096) or (x < 0) then exit(-1); // returning -1 for drowning so it can be considered in the Rate routine |
|
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
|
310 |
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
|
311 |
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
|
312 |
|
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
|
313 |
// Flags are not defined yet but 1 for checking drowning and 2 for assuming land erasure. |
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
|
314 |
function RateExplosion(Me: PGear; x, y, r: LongInt; Flags: LongWord = 0): LongInt; |
6783 | 315 |
var i, fallDmg, dmg, dmgBase, rate, erasure: LongInt; |
6775 | 316 |
dX, dY, dmgMod: real; |
4 | 317 |
begin |
6783 | 318 |
fallDmg:= 0; |
6775 | 319 |
dmgMod:= 0.01 * hwFloat2Float(cDamageModifier) * cDamagePercent; |
2695 | 320 |
rate:= 0; |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
321 |
// add our virtual position |
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
322 |
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
|
323 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
324 |
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
|
325 |
Point.y:= hwRound(Me^.Y); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
326 |
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
|
327 |
end; |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
328 |
// rate explosion |
6766
31ba56a8ec43
Minor optimisation for AI to cut down on hwSqrt calls
nemo
parents:
6700
diff
changeset
|
329 |
dmgBase:= r + cHHRadius div 2; |
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
|
330 |
if (Flags and 2 <> 0) and (GameFlags and gfSolidLand = 0) then erasure:= r |
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
|
331 |
else erasure:= 0; |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
332 |
for i:= 0 to Targets.Count do |
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
333 |
with Targets.ar[i] do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
334 |
begin |
6766
31ba56a8ec43
Minor optimisation for AI to cut down on hwSqrt calls
nemo
parents:
6700
diff
changeset
|
335 |
dmg:= 0; |
31ba56a8ec43
Minor optimisation for AI to cut down on hwSqrt calls
nemo
parents:
6700
diff
changeset
|
336 |
if abs(Point.x - x) + abs(Point.y - y) < dmgBase then |
6775 | 337 |
dmg:= trunc(dmgMod * min((dmgBase - trunc(sqrt(sqr(Point.x - x)+sqr(Point.y - y)))) div 2, r)); |
5642 | 338 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
339 |
if dmg > 0 then |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
340 |
begin |
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
|
341 |
if Flags and 1 <> 0 then |
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
|
342 |
begin |
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
|
343 |
dX:= 0.005 * dmg + 0.01; |
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
|
344 |
dY:= dX; |
6783 | 345 |
fallDmg:= trunc(TraceFall(x, y, Point.x, Point.y, dX, dY, erasure) * dmgMod); |
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
|
346 |
end; |
6783 | 347 |
if fallDmg < 0 then // drowning. score healthier hogs higher, since their death is more likely to benefit the AI |
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
|
348 |
if Score > 0 then |
6773
46cd5dad1a28
Hm. Score was a bit too much, AI was doing suicidal things.
nemo
parents:
6772
diff
changeset
|
349 |
inc(rate, KillScore + Score div 10) // Add a bit of a bonus for bigger hog drownings |
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
|
350 |
else |
6773
46cd5dad1a28
Hm. Score was a bit too much, AI was doing suicidal things.
nemo
parents:
6772
diff
changeset
|
351 |
dec(rate, KillScore * friendlyfactor div 100 - Score div 10) // and more of a punishment for drowning bigger friendly hogs |
6783 | 352 |
else if (dmg+fallDmg) >= abs(Score) then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
353 |
if Score > 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
354 |
inc(rate, KillScore) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
355 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
356 |
dec(rate, KillScore * friendlyfactor div 100) |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
357 |
else |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
358 |
if Score > 0 then |
6783 | 359 |
inc(rate, dmg+fallDmg) |
6785 | 360 |
else dec(rate, (dmg+fallDmg) * friendlyfactor div 100) |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
361 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
362 |
end; |
2695 | 363 |
RateExplosion:= rate * 1024; |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
364 |
end; |
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
365 |
|
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
|
366 |
function RateShove(Me: PGear; x, y, r, power, kick: LongInt; gdX, gdY: real; Flags: LongWord): LongInt; |
6783 | 367 |
var i, fallDmg, dmg, rate: LongInt; |
6775 | 368 |
dX, dY, dmgMod: real; |
79 | 369 |
begin |
6783 | 370 |
fallDmg:= 0; |
6775 | 371 |
dX:= gdX * 0.005 * kick; |
372 |
dY:= gdY * 0.005 * kick; |
|
373 |
dmgMod:= 0.01 * hwFloat2Float(cDamageModifier) * cDamagePercent; |
|
2695 | 374 |
rate:= 0; |
433 | 375 |
for i:= 0 to Pred(Targets.Count) do |
79 | 376 |
with Targets.ar[i] do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
377 |
begin |
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
|
378 |
dmg:= 0; |
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
|
379 |
if abs(Point.x - x) + abs(Point.y - y) < r then |
6771 | 380 |
begin |
6775 | 381 |
dmg:= r - trunc(sqrt(sqr(Point.x - x)+sqr(Point.y - y))); |
382 |
dmg:= trunc(dmg * dmgMod); |
|
6771 | 383 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
384 |
if dmg > 0 then |
79 | 385 |
begin |
6783 | 386 |
if (Flags and 1 <> 0) then |
387 |
fallDmg:= trunc(TraceShoveFall(Me, Point.x, Point.y-2, dX, dY) * dmgMod); |
|
388 |
if fallDmg < 0 then // drowning. score healthier hogs higher, since their death is more likely to benefit the AI |
|
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
|
389 |
if Score > 0 then |
6774
237b96f06aae
Try adding it to deagle too. Although the routine still doesn't consider angle, so it'll pretty much be luck. Might be a waste of time.
nemo
parents:
6773
diff
changeset
|
390 |
inc(rate, KillScore + Score div 10) // Add a bit of a bonus for bigger hog drownings |
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
|
391 |
else |
6774
237b96f06aae
Try adding it to deagle too. Although the routine still doesn't consider angle, so it'll pretty much be luck. Might be a waste of time.
nemo
parents:
6773
diff
changeset
|
392 |
dec(rate, KillScore * friendlyfactor div 100 - Score div 10) // and more of a punishment for drowning bigger friendly hogs |
6783 | 393 |
else if power+fallDmg >= abs(Score) then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
394 |
if Score > 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
395 |
inc(rate, KillScore) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
396 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
397 |
dec(rate, KillScore * friendlyfactor div 100) |
79 | 398 |
else |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
399 |
if Score > 0 then |
6783 | 400 |
inc(rate, power+fallDmg) |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
401 |
else |
6783 | 402 |
dec(rate, (power+fallDmg) * friendlyfactor div 100) |
79 | 403 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
404 |
end; |
2695 | 405 |
RateShove:= rate * 1024 |
79 | 406 |
end; |
407 |
||
6771 | 408 |
function RateShotgun(Me: PGear; gdX, gdY: real; x, y: LongInt): LongInt; |
6783 | 409 |
var i, dmg, fallDmg, baseDmg, rate, erasure: LongInt; |
6775 | 410 |
dX, dY, dmgMod: real; |
509 | 411 |
begin |
6775 | 412 |
dmgMod:= 0.01 * hwFloat2Float(cDamageModifier) * cDamagePercent; |
2695 | 413 |
rate:= 0; |
6776 | 414 |
gdX:= gdX * 0.01; |
415 |
gdY:= gdX * 0.01; |
|
509 | 416 |
// add our virtual position |
417 |
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
|
418 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
419 |
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
|
420 |
Point.y:= hwRound(Me^.Y); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
421 |
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
|
422 |
end; |
509 | 423 |
// rate shot |
6771 | 424 |
baseDmg:= cHHRadius + cShotgunRadius + 4; |
425 |
if GameFlags and gfSolidLand = 0 then erasure:= cShotgunRadius |
|
426 |
else erasure:= 0; |
|
509 | 427 |
for i:= 0 to Targets.Count do |
428 |
with Targets.ar[i] do |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
429 |
begin |
6771 | 430 |
dmg:= 0; |
431 |
if abs(Point.x - x) + abs(Point.y - y) < baseDmg then |
|
432 |
begin |
|
6775 | 433 |
dmg:= min(baseDmg - trunc(sqrt(sqr(Point.x - x)+sqr(Point.y - y))), 25); |
434 |
dmg:= trunc(dmg * dmgMod); |
|
6771 | 435 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
436 |
if dmg > 0 then |
509 | 437 |
begin |
6775 | 438 |
dX:= gdX * dmg; |
439 |
dY:= gdY * dmg; |
|
6771 | 440 |
if dX < 0 then dX:= dX - 0.01 |
441 |
else dX:= dX + 0.01; |
|
6783 | 442 |
fallDmg:= trunc(TraceFall(x, y, Point.x, Point.y, dX, dY, erasure) * dmgMod); |
443 |
if fallDmg < 0 then // drowning. score healthier hogs higher, since their death is more likely to benefit the AI |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
444 |
if Score > 0 then |
6774
237b96f06aae
Try adding it to deagle too. Although the routine still doesn't consider angle, so it'll pretty much be luck. Might be a waste of time.
nemo
parents:
6773
diff
changeset
|
445 |
inc(rate, KillScore + Score div 10) // Add a bit of a bonus for bigger hog drownings |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
446 |
else |
6774
237b96f06aae
Try adding it to deagle too. Although the routine still doesn't consider angle, so it'll pretty much be luck. Might be a waste of time.
nemo
parents:
6773
diff
changeset
|
447 |
dec(rate, KillScore * friendlyfactor div 100 - Score div 10) // and more of a punishment for drowning bigger friendly hogs |
6783 | 448 |
else if (dmg+fallDmg) >= abs(Score) then |
449 |
if Score > 0 then |
|
450 |
inc(rate, KillScore) |
|
451 |
else |
|
452 |
dec(rate, KillScore * friendlyfactor div 100) |
|
6771 | 453 |
else |
6783 | 454 |
if Score > 0 then |
455 |
inc(rate, dmg+fallDmg) |
|
456 |
else |
|
457 |
dec(rate, (dmg+fallDmg) * friendlyfactor div 100) |
|
509 | 458 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
459 |
end; |
2695 | 460 |
RateShotgun:= rate * 1024; |
509 | 461 |
end; |
462 |
||
5645 | 463 |
function RateHammer(Me: PGear): LongInt; |
464 |
var x, y, i, r, rate: LongInt; |
|
465 |
begin |
|
466 |
// hammer hit shift against attecker hog is 10 |
|
467 |
x:= hwRound(Me^.X) + hwSign(Me^.dX) * 10; |
|
468 |
y:= hwRound(Me^.Y); |
|
469 |
rate:= 0; |
|
470 |
||
471 |
for i:= 0 to Pred(Targets.Count) do |
|
472 |
with Targets.ar[i] do |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
473 |
begin |
5645 | 474 |
// hammer hit radius is 8, shift is 10 |
6775 | 475 |
if abs(Point.x - x) + abs(Point.y - y) < 18 then |
6785 | 476 |
r:= trunc(sqrt(sqr(Point.x - x)+sqr(Point.y - y))); |
5645 | 477 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
478 |
if r <= 18 then |
5645 | 479 |
if Score > 0 then |
480 |
inc(rate, Score div 3) |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
481 |
else |
5645 | 482 |
inc(rate, Score div 3 * friendlyfactor div 100) |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
483 |
end; |
5645 | 484 |
RateHammer:= rate * 1024; |
485 |
end; |
|
486 |
||
369 | 487 |
function HHJump(Gear: PGear; JumpType: TJumpType; var GoInfo: TGoInfo): boolean; |
371 | 488 |
var bX, bY: LongInt; |
2695 | 489 |
bRes: boolean; |
80 | 490 |
begin |
2695 | 491 |
bRes:= false; |
80 | 492 |
GoInfo.Ticks:= 0; |
493 |
GoInfo.JumpType:= jmpNone; |
|
369 | 494 |
bX:= hwRound(Gear^.X); |
495 |
bY:= hwRound(Gear^.Y); |
|
80 | 496 |
case JumpType of |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
497 |
jmpNone: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
498 |
exit(bRes); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
499 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
500 |
jmpHJump: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
501 |
if TestCollisionYwithGear(Gear, -1) = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
502 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
503 |
Gear^.dY:= -_0_2; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
504 |
SetLittle(Gear^.dX); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
505 |
Gear^.State:= Gear^.State or gstMoving or gstHHJumping; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
506 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
507 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
508 |
exit(bRes); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
509 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
510 |
jmpLJump: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
511 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
512 |
if TestCollisionYwithGear(Gear, -1) <> 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
513 |
if not TestCollisionXwithXYShift(Gear, _0, -2, hwSign(Gear^.dX)) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
514 |
Gear^.Y:= Gear^.Y - int2hwFloat(2) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
515 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
516 |
if not TestCollisionXwithXYShift(Gear, _0, -1, hwSign(Gear^.dX)) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
517 |
Gear^.Y:= Gear^.Y - _1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
518 |
if not (TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
519 |
or (TestCollisionYwithGear(Gear, -1) <> 0)) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
520 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
521 |
Gear^.dY:= -_0_15; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
522 |
Gear^.dX:= SignAs(_0_15, Gear^.dX); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
523 |
Gear^.State:= Gear^.State or gstMoving or gstHHJumping |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
524 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
525 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
526 |
exit(bRes) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
527 |
end |
80 | 528 |
end; |
2376 | 529 |
|
80 | 530 |
repeat |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
531 |
if not (hwRound(Gear^.Y) + cHHRadius < cWaterLine) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
532 |
exit(bRes); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
533 |
if (Gear^.State and gstMoving) <> 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
534 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
535 |
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
|
536 |
if (not (hwAbs(Gear^.dX) > cLittle)) and (Gear^.dY < -_0_02) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
537 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
538 |
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
|
539 |
Gear^.dX:= SignAs(_0_02, Gear^.dX) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
540 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
541 |
if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) then SetLittle(Gear^.dX); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
542 |
Gear^.X:= Gear^.X + Gear^.dX; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
543 |
inc(GoInfo.Ticks); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
544 |
Gear^.dY:= Gear^.dY + cGravity; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
545 |
if Gear^.dY > _0_4 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
546 |
exit(bRes); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
547 |
if (Gear^.dY.isNegative)and (TestCollisionYwithGear(Gear, -1) <> 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
548 |
Gear^.dY:= _0; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
549 |
Gear^.Y:= Gear^.Y + Gear^.dY; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
550 |
if (not Gear^.dY.isNegative)and (TestCollisionYwithGear(Gear, 1) <> 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
551 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
552 |
Gear^.State:= Gear^.State and not (gstMoving or gstHHJumping); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
553 |
Gear^.dY:= _0; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
554 |
case JumpType of |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
555 |
jmpHJump: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
556 |
if bY - hwRound(Gear^.Y) > 5 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
557 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
558 |
bRes:= true; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
559 |
GoInfo.JumpType:= jmpHJump; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
560 |
inc(GoInfo.Ticks, 300 + 300) // 300 before jump, 300 after |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
561 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
562 |
jmpLJump: if abs(bX - hwRound(Gear^.X)) > 30 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
563 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
564 |
bRes:= true; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
565 |
GoInfo.JumpType:= jmpLJump; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
566 |
inc(GoInfo.Ticks, 300 + 300) // 300 before jump, 300 after |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
567 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
568 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
569 |
exit(bRes) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
570 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
571 |
end; |
369 | 572 |
until false |
80 | 573 |
end; |
574 |
||
369 | 575 |
function HHGo(Gear, AltGear: PGear; var GoInfo: TGoInfo): boolean; |
371 | 576 |
var pX, pY: LongInt; |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
577 |
begin |
80 | 578 |
AltGear^:= Gear^; |
579 |
||
75 | 580 |
GoInfo.Ticks:= 0; |
80 | 581 |
GoInfo.FallPix:= 0; |
582 |
GoInfo.JumpType:= jmpNone; |
|
4 | 583 |
repeat |
369 | 584 |
pX:= hwRound(Gear^.X); |
585 |
pY:= hwRound(Gear^.Y); |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
586 |
if pY + cHHRadius >= cWaterLine then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
587 |
exit(false); |
542 | 588 |
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
|
589 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
590 |
inc(GoInfo.Ticks); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
591 |
Gear^.dY:= Gear^.dY + cGravity; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
592 |
if Gear^.dY > _0_4 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
593 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
594 |
Goinfo.FallPix:= 0; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
595 |
HHJump(AltGear, jmpLJump, GoInfo); // try ljump instead of fall with damage |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
596 |
exit(false) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
597 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
598 |
Gear^.Y:= Gear^.Y + Gear^.dY; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
599 |
if hwRound(Gear^.Y) > pY then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
600 |
inc(GoInfo.FallPix); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
601 |
if TestCollisionYwithGear(Gear, 1) <> 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
602 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
603 |
inc(GoInfo.Ticks, 410); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
604 |
Gear^.State:= Gear^.State and not (gstMoving or gstHHJumping); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
605 |
Gear^.dY:= _0; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
606 |
HHJump(AltGear, jmpLJump, GoInfo); // try ljump instead of fall |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
607 |
exit(true) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
608 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
609 |
continue |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
610 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
611 |
if (Gear^.Message and gmLeft )<>0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
612 |
Gear^.dX:= -cLittle |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
613 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
614 |
if (Gear^.Message and gmRight )<>0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
615 |
Gear^.dX:= cLittle |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
616 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
617 |
exit(false); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
618 |
if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
619 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
620 |
if not (TestCollisionXwithXYShift(Gear, _0, -6, hwSign(Gear^.dX)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
621 |
or (TestCollisionYwithGear(Gear, -1) <> 0)) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
622 |
Gear^.Y:= Gear^.Y - _1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
623 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
624 |
if not (TestCollisionXwithXYShift(Gear, _0, -5, hwSign(Gear^.dX)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
625 |
or (TestCollisionYwithGear(Gear, -1) <> 0)) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
626 |
Gear^.Y:= Gear^.Y - _1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
627 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
628 |
if not (TestCollisionXwithXYShift(Gear, _0, -4, hwSign(Gear^.dX)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
629 |
or (TestCollisionYwithGear(Gear, -1) <> 0)) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
630 |
Gear^.Y:= Gear^.Y - _1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
631 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
632 |
if not (TestCollisionXwithXYShift(Gear, _0, -3, hwSign(Gear^.dX)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
633 |
or (TestCollisionYwithGear(Gear, -1) <> 0)) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
634 |
Gear^.Y:= Gear^.Y - _1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
635 |
if not (TestCollisionXwithXYShift(Gear, _0, -2, hwSign(Gear^.dX)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
636 |
or (TestCollisionYwithGear(Gear, -1) <> 0)) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
637 |
Gear^.Y:= Gear^.Y - _1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
638 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
639 |
if not (TestCollisionXwithXYShift(Gear, _0, -1, hwSign(Gear^.dX)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
640 |
or (TestCollisionYwithGear(Gear, -1) <> 0)) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
641 |
Gear^.Y:= Gear^.Y - _1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
642 |
end; |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
643 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
644 |
if not TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
645 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
646 |
Gear^.X:= Gear^.X + int2hwFloat(hwSign(Gear^.dX)); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
647 |
inc(GoInfo.Ticks, cHHStepTicks) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
648 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
649 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
650 |
if TestCollisionYwithGear(Gear, 1) = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
651 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
652 |
Gear^.Y:= Gear^.Y + _1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
653 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
654 |
if TestCollisionYwithGear(Gear, 1) = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
655 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
656 |
Gear^.Y:= Gear^.Y + _1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
657 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
658 |
if TestCollisionYwithGear(Gear, 1) = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
659 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
660 |
Gear^.Y:= Gear^.Y + _1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
661 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
662 |
if TestCollisionYwithGear(Gear, 1) = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
663 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
664 |
Gear^.Y:= Gear^.Y + _1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
665 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
666 |
if TestCollisionYwithGear(Gear, 1) = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
667 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
668 |
Gear^.Y:= Gear^.Y + _1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
669 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
670 |
if TestCollisionYwithGear(Gear, 1) = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
671 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
672 |
Gear^.Y:= Gear^.Y + _1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
673 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
674 |
if TestCollisionYwithGear(Gear, 1) = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
675 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
676 |
Gear^.Y:= Gear^.Y - _6; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
677 |
Gear^.dY:= _0; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
678 |
Gear^.State:= Gear^.State or gstMoving |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
679 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
680 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
681 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
682 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
683 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
684 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
685 |
end; |
542 | 686 |
if (pX <> hwRound(Gear^.X)) and ((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
|
687 |
exit(true); |
542 | 688 |
until (pX = hwRound(Gear^.X)) and (pY = hwRound(Gear^.Y)) and ((Gear^.State and gstMoving) = 0); |
375 | 689 |
HHJump(AltGear, jmpHJump, GoInfo); |
5425 | 690 |
HHGo:= false; |
4 | 691 |
end; |
692 |
||
371 | 693 |
function AIrndSign(num: LongInt): LongInt; |
136 | 694 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
695 |
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
|
696 |
AIrndSign:= num |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
697 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6474
diff
changeset
|
698 |
AIrndSign:= - num |
2376 | 699 |
end; |
136 | 700 |
|
3038 | 701 |
procedure initModule; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset
|
702 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
703 |
friendlyfactor:= 300; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
704 |
KnownExplosion.X:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
705 |
KnownExplosion.Y:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
706 |
KnownExplosion.Radius:= 0; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset
|
707 |
end; |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset
|
708 |
|
3038 | 709 |
procedure freeModule; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset
|
710 |
begin |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset
|
711 |
|
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset
|
712 |
end; |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset
|
713 |
|
4 | 714 |
end. |