author | koda |
Mon, 16 Nov 2015 15:20:49 +0100 | |
changeset 11397 | a7efecf4f49f |
parent 11367 | a91c4c4fd85c |
child 11475 | 1d478892cf1c |
permissions | -rw-r--r-- |
4 | 1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
11046 | 3 |
* Copyright (c) 2004-2015 Andrey Korotaev <unC0Rr@gmail.com> |
4 | 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 |
|
4 | 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. |
|
4 | 13 |
* |
183 | 14 |
* You should have received a copy of the GNU General Public License |
15 |
* along with this program; if not, write to the Free Software |
|
10108
c68cf030eded
update FSF address. note: two sdl include files (by Sam Lantinga) still have the old FSF address in their copyright - but I ain't gonna touch their copyright headers
sheepluva
parents:
10098
diff
changeset
|
16 |
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
4 | 17 |
*) |
18 |
||
2630 | 19 |
{$INCLUDE "options.inc"} |
20 |
||
4 | 21 |
unit uAI; |
22 |
interface |
|
351 | 23 |
uses uFloat; |
2630 | 24 |
|
3038 | 25 |
procedure initModule; |
26 |
procedure freeModule; |
|
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset
|
27 |
|
433 | 28 |
procedure ProcessBot; |
64 | 29 |
procedure FreeActionsList; |
4 | 30 |
|
31 |
implementation |
|
4377 | 32 |
uses uConsts, SDLh, uAIMisc, uAIAmmoTests, uAIActions, |
8865 | 33 |
uAmmos, SysUtils, uTypes, |
7433
c7fff3e61d49
- Implement AI land marks which only used to tracks visited areas on the map for now. Significantly reduces wasting of cpu time by AI checking same place several times (10x or even more in rare cases)
unc0rr
parents:
7416
diff
changeset
|
34 |
uVariables, uCommands, uUtils, uDebug, uAILandMarks; |
4 | 35 |
|
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
36 |
var BestActions: TActions; |
509 | 37 |
CanUseAmmo: array [TAmmoType] of boolean; |
433 | 38 |
StopThinking: boolean; |
7028 | 39 |
StartTicks: Longword; |
8908
d3033e3a4113
let's try to kill the thread right away and protect the thread variable with a mutex
koda
parents:
8884
diff
changeset
|
40 |
ThinkThread: PSDL_Thread; |
d3033e3a4113
let's try to kill the thread right away and protect the thread variable with a mutex
koda
parents:
8884
diff
changeset
|
41 |
ThreadLock: PSDL_Mutex; |
599 | 42 |
|
369 | 43 |
procedure FreeActionsList; |
64 | 44 |
begin |
7026
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6992
diff
changeset
|
45 |
AddFileLog('FreeActionsList called'); |
8911 | 46 |
if (ThinkThread <> nil) then |
47 |
begin |
|
48 |
StopThinking:= true; |
|
49 |
SDL_WaitThread(ThinkThread, nil); |
|
50 |
end; |
|
8908
d3033e3a4113
let's try to kill the thread right away and protect the thread variable with a mutex
koda
parents:
8884
diff
changeset
|
51 |
SDL_LockMutex(ThreadLock); |
d3033e3a4113
let's try to kill the thread right away and protect the thread variable with a mutex
koda
parents:
8884
diff
changeset
|
52 |
ThinkThread:= nil; |
d3033e3a4113
let's try to kill the thread right away and protect the thread variable with a mutex
koda
parents:
8884
diff
changeset
|
53 |
SDL_UnlockMutex(ThreadLock); |
434 | 54 |
|
7026
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6992
diff
changeset
|
55 |
with CurrentHedgehog^ do |
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6992
diff
changeset
|
56 |
if Gear <> nil then |
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6992
diff
changeset
|
57 |
if BotLevel <> 0 then |
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6992
diff
changeset
|
58 |
StopMessages(Gear^.Message); |
740 | 59 |
|
7026
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6992
diff
changeset
|
60 |
BestActions.Count:= 0; |
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6992
diff
changeset
|
61 |
BestActions.Pos:= 0 |
369 | 62 |
end; |
63 |
||
6392 | 64 |
|
65 |
const cBranchStackSize = 12; |
|
66 |
type TStackEntry = record |
|
67 |
WastedTicks: Longword; |
|
68 |
MadeActions: TActions; |
|
69 |
Hedgehog: TGear; |
|
70 |
end; |
|
71 |
||
72 |
var Stack: record |
|
73 |
Count: Longword; |
|
74 |
States: array[0..Pred(cBranchStackSize)] of TStackEntry; |
|
75 |
end; |
|
76 |
||
77 |
function Push(Ticks: Longword; const Actions: TActions; const Me: TGear; Dir: integer): boolean; |
|
78 |
var bRes: boolean; |
|
79 |
begin |
|
80 |
bRes:= (Stack.Count < cBranchStackSize) and (Actions.Count < MAXACTIONS - 5); |
|
81 |
if bRes then |
|
82 |
with Stack.States[Stack.Count] do |
|
83 |
begin |
|
84 |
WastedTicks:= Ticks; |
|
85 |
MadeActions:= Actions; |
|
86 |
Hedgehog:= Me; |
|
87 |
Hedgehog.Message:= Dir; |
|
88 |
inc(Stack.Count) |
|
89 |
end; |
|
90 |
Push:= bRes |
|
91 |
end; |
|
92 |
||
93 |
procedure Pop(var Ticks: Longword; var Actions: TActions; var Me: TGear); |
|
94 |
begin |
|
95 |
dec(Stack.Count); |
|
96 |
with Stack.States[Stack.Count] do |
|
97 |
begin |
|
98 |
Ticks:= WastedTicks; |
|
99 |
Actions:= MadeActions; |
|
100 |
Me:= Hedgehog |
|
101 |
end |
|
102 |
end; |
|
103 |
||
104 |
||
105 |
||
7789
838d2e06c377
Check cake and air attack again if walked far from initial position (not tested)
unc0rr
parents:
7787
diff
changeset
|
106 |
procedure TestAmmos(var Actions: TActions; Me: PGear; rareChecks: boolean); |
3407 | 107 |
var BotLevel: Byte; |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
542
diff
changeset
|
108 |
ap: TAttackParams; |
9495
2fc346fadae3
- AI quickly shoots with desert eagle till hits the target
unc0rr
parents:
9317
diff
changeset
|
109 |
Score, i, t, n, dAngle: LongInt; |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
110 |
a, aa: TAmmoType; |
10098
f00dee04b5d7
- Cut actions array instead of performing full copy, when it is possible
unc0rr
parents:
10084
diff
changeset
|
111 |
useThisActions: boolean; |
4 | 112 |
begin |
4372 | 113 |
BotLevel:= Me^.Hedgehog^.BotLevel; |
7078
a3408d9ba5ad
AI can't use cWindSpeedf since it now does a smooth transition
nemo
parents:
7028
diff
changeset
|
114 |
windSpeed:= hwFloat2Float(cWindSpeed); |
10098
f00dee04b5d7
- Cut actions array instead of performing full copy, when it is possible
unc0rr
parents:
10084
diff
changeset
|
115 |
useThisActions:= false; |
433 | 116 |
|
64 | 117 |
for i:= 0 to Pred(Targets.Count) do |
509 | 118 |
if (Targets.ar[i].Score >= 0) and (not StopThinking) then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
119 |
begin |
6748 | 120 |
with Me^.Hedgehog^ do |
3836
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3617
diff
changeset
|
121 |
a:= CurAmmoType; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
122 |
aa:= a; |
8865 | 123 |
SDL_delay(0); // hint to let the context switch run |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
124 |
repeat |
8865 | 125 |
if (CanUseAmmo[a]) |
126 |
and ((not rareChecks) or ((AmmoTests[a].flags and amtest_Rare) = 0)) |
|
127 |
and ((i = 0) or ((AmmoTests[a].flags and amtest_NoTarget) = 0)) |
|
7178
c61cfc9eb29d
Don't make unnecessary calls to TestWhip, TestFirePunch, TestBaseballBat and TestHammer functions as they have no need to take Targ parameter into account and thus may only be called once per position
unc0rr
parents:
7164
diff
changeset
|
128 |
then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
129 |
begin |
3407 | 130 |
{$HINTS OFF} |
8959 | 131 |
Score:= AmmoTests[a].proc(Me, Targets.ar[i], BotLevel, ap); |
3407 | 132 |
{$HINTS ON} |
10098
f00dee04b5d7
- Cut actions array instead of performing full copy, when it is possible
unc0rr
parents:
10084
diff
changeset
|
133 |
if (Score > BadTurn) and (Actions.Score + Score > BestActions.Score) then |
9003
896c6b21c87f
Best level AI should maximize the score at all costs.
unc0rr
parents:
8965
diff
changeset
|
134 |
if (BestActions.Score < 0) or (Actions.Score + Score > BestActions.Score + Byte(BotLevel - 1) * 2048) then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
135 |
begin |
10510 | 136 |
if useThisActions then |
10098
f00dee04b5d7
- Cut actions array instead of performing full copy, when it is possible
unc0rr
parents:
10084
diff
changeset
|
137 |
begin |
f00dee04b5d7
- Cut actions array instead of performing full copy, when it is possible
unc0rr
parents:
10084
diff
changeset
|
138 |
BestActions.Count:= Actions.Count |
f00dee04b5d7
- Cut actions array instead of performing full copy, when it is possible
unc0rr
parents:
10084
diff
changeset
|
139 |
end |
f00dee04b5d7
- Cut actions array instead of performing full copy, when it is possible
unc0rr
parents:
10084
diff
changeset
|
140 |
else |
f00dee04b5d7
- Cut actions array instead of performing full copy, when it is possible
unc0rr
parents:
10084
diff
changeset
|
141 |
begin |
f00dee04b5d7
- Cut actions array instead of performing full copy, when it is possible
unc0rr
parents:
10084
diff
changeset
|
142 |
BestActions:= Actions; |
f00dee04b5d7
- Cut actions array instead of performing full copy, when it is possible
unc0rr
parents:
10084
diff
changeset
|
143 |
BestActions.isWalkingToABetterPlace:= false; |
f00dee04b5d7
- Cut actions array instead of performing full copy, when it is possible
unc0rr
parents:
10084
diff
changeset
|
144 |
useThisActions:= true |
f00dee04b5d7
- Cut actions array instead of performing full copy, when it is possible
unc0rr
parents:
10084
diff
changeset
|
145 |
end; |
f00dee04b5d7
- Cut actions array instead of performing full copy, when it is possible
unc0rr
parents:
10084
diff
changeset
|
146 |
|
f00dee04b5d7
- Cut actions array instead of performing full copy, when it is possible
unc0rr
parents:
10084
diff
changeset
|
147 |
BestActions.Score:= Actions.Score + Score; |
194 | 148 |
|
10231
b2a68e75e55c
Don't activate invulnerability/vampirism between shots of multiattack weapon
unc0rr
parents:
10164
diff
changeset
|
149 |
// if not between shots, activate invulnerability/vampirism if available |
b2a68e75e55c
Don't activate invulnerability/vampirism between shots of multiattack weapon
unc0rr
parents:
10164
diff
changeset
|
150 |
if CurrentHedgehog^.MultiShootAttacks = 0 then |
10084
83156a03e574
AI always activates invulnerability and extra damage if it has them
unc0rr
parents:
10015
diff
changeset
|
151 |
begin |
10231
b2a68e75e55c
Don't activate invulnerability/vampirism between shots of multiattack weapon
unc0rr
parents:
10164
diff
changeset
|
152 |
if HHHasAmmo(Me^.Hedgehog^, amInvulnerable) > 0 then |
b2a68e75e55c
Don't activate invulnerability/vampirism between shots of multiattack weapon
unc0rr
parents:
10164
diff
changeset
|
153 |
begin |
b2a68e75e55c
Don't activate invulnerability/vampirism between shots of multiattack weapon
unc0rr
parents:
10164
diff
changeset
|
154 |
AddAction(BestActions, aia_Weapon, Longword(amInvulnerable), 80, 0, 0); |
b2a68e75e55c
Don't activate invulnerability/vampirism between shots of multiattack weapon
unc0rr
parents:
10164
diff
changeset
|
155 |
AddAction(BestActions, aia_attack, aim_push, 10, 0, 0); |
b2a68e75e55c
Don't activate invulnerability/vampirism between shots of multiattack weapon
unc0rr
parents:
10164
diff
changeset
|
156 |
AddAction(BestActions, aia_attack, aim_release, 10, 0, 0); |
b2a68e75e55c
Don't activate invulnerability/vampirism between shots of multiattack weapon
unc0rr
parents:
10164
diff
changeset
|
157 |
end; |
b2a68e75e55c
Don't activate invulnerability/vampirism between shots of multiattack weapon
unc0rr
parents:
10164
diff
changeset
|
158 |
|
b2a68e75e55c
Don't activate invulnerability/vampirism between shots of multiattack weapon
unc0rr
parents:
10164
diff
changeset
|
159 |
if HHHasAmmo(Me^.Hedgehog^, amExtraDamage) > 0 then |
b2a68e75e55c
Don't activate invulnerability/vampirism between shots of multiattack weapon
unc0rr
parents:
10164
diff
changeset
|
160 |
begin |
b2a68e75e55c
Don't activate invulnerability/vampirism between shots of multiattack weapon
unc0rr
parents:
10164
diff
changeset
|
161 |
AddAction(BestActions, aia_Weapon, Longword(amExtraDamage), 80, 0, 0); |
b2a68e75e55c
Don't activate invulnerability/vampirism between shots of multiattack weapon
unc0rr
parents:
10164
diff
changeset
|
162 |
AddAction(BestActions, aia_attack, aim_push, 10, 0, 0); |
b2a68e75e55c
Don't activate invulnerability/vampirism between shots of multiattack weapon
unc0rr
parents:
10164
diff
changeset
|
163 |
AddAction(BestActions, aia_attack, aim_release, 10, 0, 0); |
10510 | 164 |
end; |
10084
83156a03e574
AI always activates invulnerability and extra damage if it has them
unc0rr
parents:
10015
diff
changeset
|
165 |
end; |
194 | 166 |
|
7132 | 167 |
AddAction(BestActions, aia_Weapon, Longword(a), 300 + random(400), 0, 0); |
5162 | 168 |
|
7132 | 169 |
if (ap.Angle > 0) then |
170 |
AddAction(BestActions, aia_LookRight, 0, 200, 0, 0) |
|
171 |
else if (ap.Angle < 0) then |
|
172 |
AddAction(BestActions, aia_LookLeft, 0, 200, 0, 0); |
|
8865 | 173 |
|
7790 | 174 |
if (Ammoz[a].Ammo.Propz and ammoprop_Timerable) <> 0 then |
7132 | 175 |
AddAction(BestActions, aia_Timer, ap.Time div 1000, 400, 0, 0); |
8865 | 176 |
|
7132 | 177 |
if (Ammoz[a].Ammo.Propz and ammoprop_NoCrosshair) = 0 then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
178 |
begin |
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
179 |
dAngle:= LongInt(Me^.Angle) - Abs(ap.Angle); |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
180 |
if dAngle > 0 then |
7132 | 181 |
begin |
182 |
AddAction(BestActions, aia_Up, aim_push, 300 + random(250), 0, 0); |
|
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
183 |
AddAction(BestActions, aia_Up, aim_release, dAngle, 0, 0) |
7132 | 184 |
end |
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
185 |
else if dAngle < 0 then |
7132 | 186 |
begin |
187 |
AddAction(BestActions, aia_Down, aim_push, 300 + random(250), 0, 0); |
|
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
188 |
AddAction(BestActions, aia_Down, aim_release, -dAngle, 0, 0) |
7132 | 189 |
end |
190 |
end; |
|
8865 | 191 |
|
7132 | 192 |
if (Ammoz[a].Ammo.Propz and ammoprop_NeedTarget) <> 0 then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
193 |
begin |
7132 | 194 |
AddAction(BestActions, aia_Put, 0, 1, ap.AttackPutX, ap.AttackPutY) |
195 |
end; |
|
8865 | 196 |
|
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
197 |
if (Ammoz[a].Ammo.Propz and ammoprop_OscAim) <> 0 then |
7132 | 198 |
begin |
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
199 |
AddAction(BestActions, aia_attack, aim_push, 350 + random(200), 0, 0); |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
200 |
AddAction(BestActions, aia_attack, aim_release, 1, 0, 0); |
8865 | 201 |
|
7453 | 202 |
if abs(ap.Angle) > 32 then |
7450 | 203 |
begin |
204 |
AddAction(BestActions, aia_Down, aim_push, 100 + random(150), 0, 0); |
|
205 |
AddAction(BestActions, aia_Down, aim_release, 32, 0, 0); |
|
206 |
end; |
|
8865 | 207 |
|
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
208 |
AddAction(BestActions, aia_waitAngle, ap.Angle, 250, 0, 0); |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
209 |
AddAction(BestActions, aia_attack, aim_push, 1, 0, 0); |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
210 |
AddAction(BestActions, aia_attack, aim_release, 1, 0, 0); |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
211 |
end else |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
212 |
if (Ammoz[a].Ammo.Propz and ammoprop_AttackingPut) = 0 then |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
213 |
begin |
9495
2fc346fadae3
- AI quickly shoots with desert eagle till hits the target
unc0rr
parents:
9317
diff
changeset
|
214 |
if (AmmoTests[a].flags and amtest_MultipleAttacks) = 0 then |
2fc346fadae3
- AI quickly shoots with desert eagle till hits the target
unc0rr
parents:
9317
diff
changeset
|
215 |
n:= 1 else n:= ap.AttacksNum; |
2fc346fadae3
- AI quickly shoots with desert eagle till hits the target
unc0rr
parents:
9317
diff
changeset
|
216 |
|
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
217 |
AddAction(BestActions, aia_attack, aim_push, 650 + random(300), 0, 0); |
9495
2fc346fadae3
- AI quickly shoots with desert eagle till hits the target
unc0rr
parents:
9317
diff
changeset
|
218 |
for t:= 2 to n do |
2fc346fadae3
- AI quickly shoots with desert eagle till hits the target
unc0rr
parents:
9317
diff
changeset
|
219 |
begin |
2fc346fadae3
- AI quickly shoots with desert eagle till hits the target
unc0rr
parents:
9317
diff
changeset
|
220 |
AddAction(BestActions, aia_attack, aim_push, 150, 0, 0); |
2fc346fadae3
- AI quickly shoots with desert eagle till hits the target
unc0rr
parents:
9317
diff
changeset
|
221 |
AddAction(BestActions, aia_attack, aim_release, ap.Power, 0, 0); |
2fc346fadae3
- AI quickly shoots with desert eagle till hits the target
unc0rr
parents:
9317
diff
changeset
|
222 |
end; |
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
223 |
AddAction(BestActions, aia_attack, aim_release, ap.Power, 0, 0); |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
224 |
end; |
7416
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7375
diff
changeset
|
225 |
|
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7375
diff
changeset
|
226 |
if (Ammoz[a].Ammo.Propz and ammoprop_Track) <> 0 then |
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7375
diff
changeset
|
227 |
begin |
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7375
diff
changeset
|
228 |
AddAction(BestActions, aia_waitAmmoXY, 0, 12, ap.ExplX, ap.ExplY); |
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7375
diff
changeset
|
229 |
AddAction(BestActions, aia_attack, aim_push, 1, 0, 0); |
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7375
diff
changeset
|
230 |
AddAction(BestActions, aia_attack, aim_release, 7, 0, 0); |
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7375
diff
changeset
|
231 |
end; |
2f2f78fc65a3
AI uses cake! Known issues: AI could damage itself for no reason, could let cake go looping in a hole with exit closed by AI hog.
unc0rr
parents:
7375
diff
changeset
|
232 |
|
7132 | 233 |
if ap.ExplR > 0 then |
234 |
AddAction(BestActions, aia_AwareExpl, ap.ExplR, 10, ap.ExplX, ap.ExplY); |
|
235 |
end |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
236 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
237 |
if a = High(TAmmoType) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
238 |
a:= Low(TAmmoType) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
239 |
else inc(a) |
7178
c61cfc9eb29d
Don't make unnecessary calls to TestWhip, TestFirePunch, TestBaseballBat and TestHammer functions as they have no need to take Targ parameter into account and thus may only be called once per position
unc0rr
parents:
7164
diff
changeset
|
240 |
until (a = aa) or (CurrentHedgehog^.MultiShootAttacks > 0) {shooting same weapon} |
c61cfc9eb29d
Don't make unnecessary calls to TestWhip, TestFirePunch, TestBaseballBat and TestHammer functions as they have no need to take Targ parameter into account and thus may only be called once per position
unc0rr
parents:
7164
diff
changeset
|
241 |
or StopThinking |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
242 |
end |
64 | 243 |
end; |
4 | 244 |
|
6393 | 245 |
procedure Walk(Me: PGear; var Actions: TActions); |
7433
c7fff3e61d49
- Implement AI land marks which only used to tracks visited areas on the map for now. Significantly reduces wasting of cpu time by AI checking same place several times (10x or even more in rare cases)
unc0rr
parents:
7416
diff
changeset
|
246 |
const FallPixForBranching = cHHRadius; |
6393 | 247 |
var |
7789
838d2e06c377
Check cake and air attack again if walked far from initial position (not tested)
unc0rr
parents:
7787
diff
changeset
|
248 |
ticks, maxticks, oldticks, steps, tmp: Longword; |
433 | 249 |
BaseRate, BestRate, Rate: integer; |
75 | 250 |
GoInfo: TGoInfo; |
80 | 251 |
CanGo: boolean; |
252 |
AltMe: TGear; |
|
3407 | 253 |
BotLevel: Byte; |
6392 | 254 |
a: TAmmoType; |
64 | 255 |
begin |
7789
838d2e06c377
Check cake and air attack again if walked far from initial position (not tested)
unc0rr
parents:
7787
diff
changeset
|
256 |
ticks:= 0; |
838d2e06c377
Check cake and air attack again if walked far from initial position (not tested)
unc0rr
parents:
7787
diff
changeset
|
257 |
oldticks:= 0; // avoid compiler hint |
433 | 258 |
Stack.Count:= 0; |
6392 | 259 |
|
7787
67c96b9c179c
Mark places where tried to jump, avoid too much of thinking
unc0rr
parents:
7453
diff
changeset
|
260 |
clearAllMarks; |
67c96b9c179c
Mark places where tried to jump, avoid too much of thinking
unc0rr
parents:
7453
diff
changeset
|
261 |
|
6392 | 262 |
for a:= Low(TAmmoType) to High(TAmmoType) do |
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:
6748
diff
changeset
|
263 |
CanUseAmmo[a]:= Assigned(AmmoTests[a].proc) and (HHHasAmmo(Me^.Hedgehog^, a) > 0); |
6392 | 264 |
|
4372 | 265 |
BotLevel:= Me^.Hedgehog^.BotLevel; |
75 | 266 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
267 |
if (Me^.State and gstAttacked) = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
268 |
maxticks:= Max(0, TurnTimeLeft - 5000 - LongWord(4000 * BotLevel)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
269 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
270 |
maxticks:= TurnTimeLeft; |
75 | 271 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
272 |
if (Me^.State and gstAttacked) = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
273 |
TestAmmos(Actions, Me, false); |
8865 | 274 |
|
433 | 275 |
BestRate:= RatePlace(Me); |
4374 | 276 |
BaseRate:= Max(BestRate, 0); |
75 | 277 |
|
8865 | 278 |
// switch to 'skip' if we cannot move because of mouse cursor being shown |
5148
73b3b4b8359c
Make AI switch to amNothing before trying to walk if it holds weapon which needs targeting (not tested)
unc0rr
parents:
4976
diff
changeset
|
279 |
if (Ammoz[Me^.Hedgehog^.CurAmmoType].Ammo.Propz and ammoprop_NeedTarget) <> 0 then |
7132 | 280 |
AddAction(Actions, aia_Weapon, Longword(amSkip), 100 + random(200), 0, 0); |
8865 | 281 |
|
282 |
if ((CurrentHedgehog^.MultiShootAttacks = 0) or ((Ammoz[Me^.Hedgehog^.CurAmmoType].Ammo.Propz and ammoprop_NoMoveAfter) = 0)) |
|
9844 | 283 |
and (GameFlags and gfArtillery = 0) and (cGravityf <> 0) then |
433 | 284 |
begin |
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
285 |
tmp:= random(2) + 1; |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
286 |
Push(0, Actions, Me^, tmp); |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
287 |
Push(0, Actions, Me^, tmp xor 3); |
8865 | 288 |
|
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
289 |
while (Stack.Count > 0) and (not StopThinking) do |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
290 |
begin |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
291 |
Pop(ticks, Actions, Me^); |
193 | 292 |
|
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
293 |
AddAction(Actions, Me^.Message, aim_push, 250, 0, 0); |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
294 |
if (Me^.Message and gmLeft) <> 0 then |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
295 |
AddAction(Actions, aia_WaitXL, hwRound(Me^.X), 0, 0, 0) |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
296 |
else |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
297 |
AddAction(Actions, aia_WaitXR, hwRound(Me^.X), 0, 0, 0); |
8865 | 298 |
|
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
299 |
steps:= 0; |
82 | 300 |
|
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
301 |
while (not StopThinking) do |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
302 |
begin |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
303 |
{$HINTS OFF} |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
304 |
CanGo:= HHGo(Me, @AltMe, GoInfo); |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
305 |
{$HINTS ON} |
7789
838d2e06c377
Check cake and air attack again if walked far from initial position (not tested)
unc0rr
parents:
7787
diff
changeset
|
306 |
oldticks:= ticks; |
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
307 |
inc(ticks, GoInfo.Ticks); |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
308 |
if ticks > maxticks then |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
309 |
break; |
194 | 310 |
|
8865 | 311 |
if (BotLevel < 5) |
312 |
and (GoInfo.JumpType = jmpHJump) |
|
7787
67c96b9c179c
Mark places where tried to jump, avoid too much of thinking
unc0rr
parents:
7453
diff
changeset
|
313 |
and (not checkMark(hwRound(Me^.X), hwRound(Me^.Y), markHJumped)) |
67c96b9c179c
Mark places where tried to jump, avoid too much of thinking
unc0rr
parents:
7453
diff
changeset
|
314 |
then // hjump support |
67c96b9c179c
Mark places where tried to jump, avoid too much of thinking
unc0rr
parents:
7453
diff
changeset
|
315 |
begin |
7446 | 316 |
// check if we could go backwards and maybe ljump over a gap after this hjump |
7787
67c96b9c179c
Mark places where tried to jump, avoid too much of thinking
unc0rr
parents:
7453
diff
changeset
|
317 |
addMark(hwRound(Me^.X), hwRound(Me^.Y), markHJumped); |
7446 | 318 |
if Push(ticks, Actions, AltMe, Me^.Message xor 3) then |
7433
c7fff3e61d49
- Implement AI land marks which only used to tracks visited areas on the map for now. Significantly reduces wasting of cpu time by AI checking same place several times (10x or even more in rare cases)
unc0rr
parents:
7416
diff
changeset
|
319 |
begin |
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
320 |
with Stack.States[Pred(Stack.Count)] do |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
321 |
begin |
8036
89740f927254
Don't rely on hedgehog facing direction, check intentions instead. Should fix excessive turns around and weird jumps to water
unc0rr
parents:
8017
diff
changeset
|
322 |
if (Me^.Message and gmLeft) <> 0 then |
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
323 |
AddAction(MadeActions, aia_LookRight, 0, 200, 0, 0) |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
324 |
else |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
325 |
AddAction(MadeActions, aia_LookLeft, 0, 200, 0, 0); |
8865 | 326 |
|
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
327 |
AddAction(MadeActions, aia_HJump, 0, 305 + random(50), 0, 0); |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
328 |
AddAction(MadeActions, aia_HJump, 0, 350, 0, 0); |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
329 |
end; |
7446 | 330 |
// but first check walking forward |
331 |
Push(ticks, Stack.States[Pred(Stack.Count)].MadeActions, AltMe, Me^.Message) |
|
7433
c7fff3e61d49
- Implement AI land marks which only used to tracks visited areas on the map for now. Significantly reduces wasting of cpu time by AI checking same place several times (10x or even more in rare cases)
unc0rr
parents:
7416
diff
changeset
|
332 |
end; |
7787
67c96b9c179c
Mark places where tried to jump, avoid too much of thinking
unc0rr
parents:
7453
diff
changeset
|
333 |
end; |
8865 | 334 |
if (BotLevel < 3) |
335 |
and (GoInfo.JumpType = jmpLJump) |
|
7787
67c96b9c179c
Mark places where tried to jump, avoid too much of thinking
unc0rr
parents:
7453
diff
changeset
|
336 |
and (not checkMark(hwRound(Me^.X), hwRound(Me^.Y), markLJumped)) |
67c96b9c179c
Mark places where tried to jump, avoid too much of thinking
unc0rr
parents:
7453
diff
changeset
|
337 |
then // ljump support |
7250 | 338 |
begin |
7787
67c96b9c179c
Mark places where tried to jump, avoid too much of thinking
unc0rr
parents:
7453
diff
changeset
|
339 |
addMark(hwRound(Me^.X), hwRound(Me^.Y), markLJumped); |
7433
c7fff3e61d49
- Implement AI land marks which only used to tracks visited areas on the map for now. Significantly reduces wasting of cpu time by AI checking same place several times (10x or even more in rare cases)
unc0rr
parents:
7416
diff
changeset
|
340 |
// at final check where we go after jump walking backward |
c7fff3e61d49
- Implement AI land marks which only used to tracks visited areas on the map for now. Significantly reduces wasting of cpu time by AI checking same place several times (10x or even more in rare cases)
unc0rr
parents:
7416
diff
changeset
|
341 |
if Push(ticks, Actions, AltMe, Me^.Message xor 3) then |
c7fff3e61d49
- Implement AI land marks which only used to tracks visited areas on the map for now. Significantly reduces wasting of cpu time by AI checking same place several times (10x or even more in rare cases)
unc0rr
parents:
7416
diff
changeset
|
342 |
with Stack.States[Pred(Stack.Count)] do |
8017 | 343 |
begin |
8036
89740f927254
Don't rely on hedgehog facing direction, check intentions instead. Should fix excessive turns around and weird jumps to water
unc0rr
parents:
8017
diff
changeset
|
344 |
if (Me^.Message and gmLeft) <> 0 then |
8017 | 345 |
AddAction(MadeActions, aia_LookLeft, 0, 200, 0, 0) |
346 |
else |
|
347 |
AddAction(MadeActions, aia_LookRight, 0, 200, 0, 0); |
|
348 |
||
7433
c7fff3e61d49
- Implement AI land marks which only used to tracks visited areas on the map for now. Significantly reduces wasting of cpu time by AI checking same place several times (10x or even more in rare cases)
unc0rr
parents:
7416
diff
changeset
|
349 |
AddAction(MadeActions, aia_LJump, 0, 305 + random(50), 0, 0); |
8017 | 350 |
end; |
7433
c7fff3e61d49
- Implement AI land marks which only used to tracks visited areas on the map for now. Significantly reduces wasting of cpu time by AI checking same place several times (10x or even more in rare cases)
unc0rr
parents:
7416
diff
changeset
|
351 |
|
c7fff3e61d49
- Implement AI land marks which only used to tracks visited areas on the map for now. Significantly reduces wasting of cpu time by AI checking same place several times (10x or even more in rare cases)
unc0rr
parents:
7416
diff
changeset
|
352 |
// push current position so we proceed from it after checking jump+forward walk opportunities |
7250 | 353 |
if CanGo then Push(ticks, Actions, Me^, Me^.Message); |
8865 | 354 |
|
7433
c7fff3e61d49
- Implement AI land marks which only used to tracks visited areas on the map for now. Significantly reduces wasting of cpu time by AI checking same place several times (10x or even more in rare cases)
unc0rr
parents:
7416
diff
changeset
|
355 |
// first check where we go after jump walking forward |
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
356 |
if Push(ticks, Actions, AltMe, Me^.Message) then |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
357 |
with Stack.States[Pred(Stack.Count)] do |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
358 |
AddAction(MadeActions, aia_LJump, 0, 305 + random(50), 0, 0); |
7250 | 359 |
break |
360 |
end; |
|
433 | 361 |
|
8865 | 362 |
// 'not CanGO' means we cannot go straight, possible jumps are checked above |
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
363 |
if not CanGo then |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
364 |
break; |
8865 | 365 |
|
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
366 |
inc(steps); |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
367 |
Actions.actions[Pred(Actions.Count)].Param:= hwRound(Me^.X); |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
368 |
Rate:= RatePlace(Me); |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
369 |
if Rate > BestRate then |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
370 |
begin |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
371 |
BestActions:= Actions; |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
372 |
BestActions.isWalkingToABetterPlace:= true; |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
373 |
BestRate:= Rate; |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
374 |
Me^.State:= Me^.State or gstAttacked // we have better place, go there and do not use ammo |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
375 |
end |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
376 |
else if Rate < BestRate then |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
377 |
break; |
8865 | 378 |
|
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
379 |
if ((Me^.State and gstAttacked) = 0) and ((steps mod 4) = 0) then |
7433
c7fff3e61d49
- Implement AI land marks which only used to tracks visited areas on the map for now. Significantly reduces wasting of cpu time by AI checking same place several times (10x or even more in rare cases)
unc0rr
parents:
7416
diff
changeset
|
380 |
begin |
7787
67c96b9c179c
Mark places where tried to jump, avoid too much of thinking
unc0rr
parents:
7453
diff
changeset
|
381 |
if (steps > 4) and checkMark(hwRound(Me^.X), hwRound(Me^.Y), markWalkedHere) then |
8865 | 382 |
break; |
7787
67c96b9c179c
Mark places where tried to jump, avoid too much of thinking
unc0rr
parents:
7453
diff
changeset
|
383 |
addMark(hwRound(Me^.X), hwRound(Me^.Y), markWalkedHere); |
7789
838d2e06c377
Check cake and air attack again if walked far from initial position (not tested)
unc0rr
parents:
7787
diff
changeset
|
384 |
|
838d2e06c377
Check cake and air attack again if walked far from initial position (not tested)
unc0rr
parents:
7787
diff
changeset
|
385 |
TestAmmos(Actions, Me, ticks shr 12 = oldticks shr 12); |
8865 | 386 |
|
7433
c7fff3e61d49
- Implement AI land marks which only used to tracks visited areas on the map for now. Significantly reduces wasting of cpu time by AI checking same place several times (10x or even more in rare cases)
unc0rr
parents:
7416
diff
changeset
|
387 |
end; |
8865 | 388 |
|
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
389 |
if GoInfo.FallPix >= FallPixForBranching then |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
390 |
Push(ticks, Actions, Me^, Me^.Message xor 3); // aia_Left xor 3 = aia_Right |
8026
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7790
diff
changeset
|
391 |
|
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7790
diff
changeset
|
392 |
if (StartTicks > GameTicks - 1500) and (not StopThinking) then |
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7790
diff
changeset
|
393 |
SDL_Delay(1000); |
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7790
diff
changeset
|
394 |
|
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
395 |
end {while}; |
193 | 396 |
|
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
397 |
if BestRate > BaseRate then |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
398 |
exit |
7164
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7132
diff
changeset
|
399 |
end {while} |
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
400 |
end {if} |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
401 |
end; |
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
402 |
|
8865 | 403 |
function Think(Me: PGear): LongInt; cdecl; export; |
74 | 404 |
var BackMe, WalkMe: TGear; |
6992 | 405 |
switchCount: LongInt; |
8026
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7790
diff
changeset
|
406 |
currHedgehogIndex, itHedgehog, switchesNum, i: Longword; |
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:
6748
diff
changeset
|
407 |
switchImmediatelyAvailable: boolean; |
6393 | 408 |
Actions: TActions; |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
409 |
begin |
8884
08fe08651130
set translucency on fruit theme water, clamp size to even number (same sdl window resize) and honouring min size, reduce calls to dmgmod a bit
nemo
parents:
8865
diff
changeset
|
410 |
dmgMod:= 0.01 * hwFloat2Float(cDamageModifier) * cDamagePercent; |
433 | 411 |
StartTicks:= GameTicks; |
8026
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7790
diff
changeset
|
412 |
|
6393 | 413 |
currHedgehogIndex:= CurrentTeam^.CurrHedgehog; |
414 |
itHedgehog:= currHedgehogIndex; |
|
415 |
switchesNum:= 0; |
|
416 |
||
417 |
switchImmediatelyAvailable:= (CurAmmoGear <> nil) and (CurAmmoGear^.Kind = gtSwitcher); |
|
8865 | 418 |
if Me^.Hedgehog^.BotLevel <> 5 then |
7375
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7250
diff
changeset
|
419 |
switchCount:= HHHasAmmo(PGear(Me)^.Hedgehog^, amSwitch) |
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7250
diff
changeset
|
420 |
else switchCount:= 0; |
509 | 421 |
|
10164
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10108
diff
changeset
|
422 |
if ((Me^.State and gstAttacked) = 0) or isInMultiShoot or bonuses.activity then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
423 |
if Targets.Count > 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
424 |
begin |
6393 | 425 |
// iterate over current team hedgehogs |
426 |
repeat |
|
427 |
WalkMe:= CurrentTeam^.Hedgehogs[itHedgehog].Gear^; |
|
428 |
||
429 |
Actions.Count:= 0; |
|
430 |
Actions.Pos:= 0; |
|
431 |
Actions.Score:= 0; |
|
432 |
if switchesNum > 0 then |
|
433 |
begin |
|
8026
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7790
diff
changeset
|
434 |
if (not switchImmediatelyAvailable) then |
6393 | 435 |
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:
6748
diff
changeset
|
436 |
// when AI has to use switcher, make it cost smth unless they have a lot of switches |
6992 | 437 |
if (switchCount < 10) then Actions.Score:= (-27+switchCount*3)*4000; |
8865 | 438 |
AddAction(Actions, aia_Weapon, Longword(amSwitch), 300 + random(200), 0, 0); |
6393 | 439 |
AddAction(Actions, aia_attack, aim_push, 300 + random(300), 0, 0); |
440 |
AddAction(Actions, aia_attack, aim_release, 1, 0, 0); |
|
441 |
end; |
|
442 |
for i:= 1 to switchesNum do |
|
443 |
AddAction(Actions, aia_Switch, 0, 300 + random(200), 0, 0); |
|
444 |
end; |
|
445 |
Walk(@WalkMe, Actions); |
|
446 |
||
447 |
// find another hog in team |
|
448 |
repeat |
|
449 |
itHedgehog:= Succ(itHedgehog) mod CurrentTeam^.HedgehogsNumber; |
|
8677 | 450 |
until (itHedgehog = currHedgehogIndex) or ((CurrentTeam^.Hedgehogs[itHedgehog].Gear <> nil) and (CurrentTeam^.Hedgehogs[itHedgehog].Effects[heFrozen]=0)); |
6393 | 451 |
|
452 |
inc(switchesNum); |
|
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:
6748
diff
changeset
|
453 |
until (not (switchImmediatelyAvailable or (switchCount > 0))) |
8865 | 454 |
or StopThinking |
6395
bb04d7a9f7e2
Make AI be less scared by crates. Actually, now it starts using switcher just to pick a crate up.
unc0rr
parents:
6393
diff
changeset
|
455 |
or (itHedgehog = currHedgehogIndex) |
bb04d7a9f7e2
Make AI be less scared by crates. Actually, now it starts using switcher just to pick a crate up.
unc0rr
parents:
6393
diff
changeset
|
456 |
or BestActions.isWalkingToABetterPlace; |
6393 | 457 |
|
10015 | 458 |
if (StartTicks > GameTicks - 1500) and (not StopThinking) then |
10164
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10108
diff
changeset
|
459 |
SDL_Delay(700); |
6393 | 460 |
|
6395
bb04d7a9f7e2
Make AI be less scared by crates. Actually, now it starts using switcher just to pick a crate up.
unc0rr
parents:
6393
diff
changeset
|
461 |
if (BestActions.Score < -1023) and (not BestActions.isWalkingToABetterPlace) then |
6393 | 462 |
begin |
463 |
BestActions.Count:= 0; |
|
10164
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10108
diff
changeset
|
464 |
|
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10108
diff
changeset
|
465 |
FillBonuses(false); |
10510 | 466 |
|
10164
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10108
diff
changeset
|
467 |
if not bonuses.activity then |
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10108
diff
changeset
|
468 |
AddAction(BestActions, aia_Skip, 0, 250, 0, 0); |
6393 | 469 |
end; |
470 |
||
8017 | 471 |
end else SDL_Delay(100) |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
472 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
473 |
begin |
8865 | 474 |
BackMe:= Me^; |
10164
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10108
diff
changeset
|
475 |
i:= 4; |
8946 | 476 |
while (not StopThinking) and (BestActions.Count = 0) and (i > 0) do |
6393 | 477 |
begin |
8026
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7790
diff
changeset
|
478 |
|
7375
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7250
diff
changeset
|
479 |
(* |
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7250
diff
changeset
|
480 |
// Maybe this would get a bit of movement out of them? Hopefully not *toward* water. Need to check how often he'd choose that strategy |
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7250
diff
changeset
|
481 |
if SuddenDeathDmg and ((hwRound(BackMe.Y)+cWaterRise*2) > cWaterLine) then |
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7250
diff
changeset
|
482 |
AddBonus(hwRound(BackMe.X), hwRound(BackMe.Y), 250, -40); |
16ae2e1c9005
Tell AI to avoid edges, especially ones over water (this does not include checking whether a knock could drown yet). Also make flakes pick a new random dx/dy on respawn to further reduce patterns. Also disable a couple of weapons for the particularly dumb AI levels, and disable switching for the dumbest.
nemo
parents:
7250
diff
changeset
|
483 |
*) |
8026
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7790
diff
changeset
|
484 |
|
6393 | 485 |
FillBonuses(true); |
486 |
WalkMe:= BackMe; |
|
487 |
Actions.Count:= 0; |
|
488 |
Actions.Pos:= 0; |
|
489 |
Actions.Score:= 0; |
|
490 |
Walk(@WalkMe, Actions); |
|
10164
0570d4b22187
AI doesn't skip till action on the map stops (mostly dedicated to highlander) + various small tweaks
unc0rr
parents:
10108
diff
changeset
|
491 |
if not bonuses.activity then dec(i); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
492 |
if not StopThinking then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
493 |
SDL_Delay(100) |
6393 | 494 |
end |
495 |
end; |
|
496 |
||
8865 | 497 |
Me^.State:= Me^.State and (not gstHHThinking); |
8908
d3033e3a4113
let's try to kill the thread right away and protect the thread variable with a mutex
koda
parents:
8884
diff
changeset
|
498 |
SDL_LockMutex(ThreadLock); |
8865 | 499 |
ThinkThread:= nil; |
8908
d3033e3a4113
let's try to kill the thread right away and protect the thread variable with a mutex
koda
parents:
8884
diff
changeset
|
500 |
SDL_UnlockMutex(ThreadLock); |
509 | 501 |
Think:= 0; |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
502 |
end; |
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
503 |
|
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
504 |
procedure StartThink(Me: PGear); |
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
505 |
begin |
542 | 506 |
if ((Me^.State and (gstAttacking or gstHHJumping or gstMoving)) <> 0) |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
507 |
or isInMultiShoot then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
508 |
exit; |
506 | 509 |
|
7433
c7fff3e61d49
- Implement AI land marks which only used to tracks visited areas on the map for now. Significantly reduces wasting of cpu time by AI checking same place several times (10x or even more in rare cases)
unc0rr
parents:
7416
diff
changeset
|
510 |
//DeleteCI(Me); // this will break demo/netplay |
c7fff3e61d49
- Implement AI land marks which only used to tracks visited areas on the map for now. Significantly reduces wasting of cpu time by AI checking same place several times (10x or even more in rare cases)
unc0rr
parents:
7416
diff
changeset
|
511 |
|
369 | 512 |
Me^.State:= Me^.State or gstHHThinking; |
513 |
Me^.Message:= 0; |
|
509 | 514 |
|
515 |
BestActions.Count:= 0; |
|
516 |
BestActions.Pos:= 0; |
|
5163 | 517 |
BestActions.Score:= Low(LongInt); |
6395
bb04d7a9f7e2
Make AI be less scared by crates. Actually, now it starts using switcher just to pick a crate up.
unc0rr
parents:
6393
diff
changeset
|
518 |
BestActions.isWalkingToABetterPlace:= false; |
509 | 519 |
|
433 | 520 |
StopThinking:= false; |
521 |
ThinkingHH:= Me; |
|
509 | 522 |
|
70 | 523 |
FillTargets; |
80 | 524 |
if Targets.Count = 0 then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
525 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
526 |
OutError('AI: no targets!?', false); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
527 |
exit |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
528 |
end; |
941
b5222ddafe1f
- Fix bug with picking up ammos from cases, when total ammo count may become more than AMMO_INFINITE
unc0rr
parents:
936
diff
changeset
|
529 |
|
8946 | 530 |
FillBonuses(((Me^.State and gstAttacked) <> 0) and (not isInMultiShoot)); |
8908
d3033e3a4113
let's try to kill the thread right away and protect the thread variable with a mutex
koda
parents:
8884
diff
changeset
|
531 |
|
d3033e3a4113
let's try to kill the thread right away and protect the thread variable with a mutex
koda
parents:
8884
diff
changeset
|
532 |
SDL_LockMutex(ThreadLock); |
11367 | 533 |
ThinkThread:= SDL_CreateThread(@Think, PChar('think'), Me); |
8908
d3033e3a4113
let's try to kill the thread right away and protect the thread variable with a mutex
koda
parents:
8884
diff
changeset
|
534 |
SDL_UnlockMutex(ThreadLock); |
433 | 535 |
end; |
191
a03c2d037e24
Bots are in the same thread as game. Fixes FreePascal issues.
unc0rr
parents:
183
diff
changeset
|
536 |
|
8965 | 537 |
{$IFDEF DEBUGAI} |
538 |
var scoreShown: boolean = false; |
|
539 |
{$ENDIF} |
|
7204
522f165cd2e7
- Fix damage calculation in TestSniperRifle, aim a bit lower to compensate initial angle shift in sniper rifle. As a result, AI seems to never fail sniper rifle shots.
unc0rr
parents:
7197
diff
changeset
|
540 |
|
433 | 541 |
procedure ProcessBot; |
6982 | 542 |
const cStopThinkTime = 40; |
4 | 543 |
begin |
602 | 544 |
with CurrentHedgehog^ do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
545 |
if (Gear <> nil) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
546 |
and ((Gear^.State and gstHHDriven) <> 0) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
547 |
and (TurnTimeLeft < cHedgehogTurnTime - 50) then |
433 | 548 |
if ((Gear^.State and gstHHThinking) = 0) then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
549 |
if (BestActions.Pos >= BestActions.Count) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
550 |
and (TurnTimeLeft > cStopThinkTime) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
551 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
552 |
if Gear^.Message <> 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
553 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
554 |
StopMessages(Gear^.Message); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
555 |
TryDo((Gear^.Message and gmAllStoppable) = 0, 'Engine bug: AI may break demos playing', true); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
556 |
end; |
8865 | 557 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
558 |
if Gear^.Message <> 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
559 |
exit; |
8865 | 560 |
|
8965 | 561 |
{$IFDEF DEBUGAI} |
562 |
scoreShown:= false; |
|
563 |
{$ENDIF} |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
564 |
StartThink(Gear); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
565 |
StartTicks:= GameTicks |
8865 | 566 |
|
7204
522f165cd2e7
- Fix damage calculation in TestSniperRifle, aim a bit lower to compensate initial angle shift in sniper rifle. As a result, AI seems to never fail sniper rifle shots.
unc0rr
parents:
7197
diff
changeset
|
567 |
end else |
522f165cd2e7
- Fix damage calculation in TestSniperRifle, aim a bit lower to compensate initial angle shift in sniper rifle. As a result, AI seems to never fail sniper rifle shots.
unc0rr
parents:
7197
diff
changeset
|
568 |
begin |
8965 | 569 |
{$IFDEF DEBUGAI} |
570 |
if not scoreShown then |
|
7204
522f165cd2e7
- Fix damage calculation in TestSniperRifle, aim a bit lower to compensate initial angle shift in sniper rifle. As a result, AI seems to never fail sniper rifle shots.
unc0rr
parents:
7197
diff
changeset
|
571 |
begin |
522f165cd2e7
- Fix damage calculation in TestSniperRifle, aim a bit lower to compensate initial angle shift in sniper rifle. As a result, AI seems to never fail sniper rifle shots.
unc0rr
parents:
7197
diff
changeset
|
572 |
if BestActions.Score > 0 then ParseCommand('/say Expected score = ' + inttostr(BestActions.Score div 1024), true); |
522f165cd2e7
- Fix damage calculation in TestSniperRifle, aim a bit lower to compensate initial angle shift in sniper rifle. As a result, AI seems to never fail sniper rifle shots.
unc0rr
parents:
7197
diff
changeset
|
573 |
scoreShown:= true |
8965 | 574 |
end; |
575 |
{$ENDIF} |
|
7204
522f165cd2e7
- Fix damage calculation in TestSniperRifle, aim a bit lower to compensate initial angle shift in sniper rifle. As a result, AI seems to never fail sniper rifle shots.
unc0rr
parents:
7197
diff
changeset
|
576 |
ProcessAction(BestActions, Gear) |
522f165cd2e7
- Fix damage calculation in TestSniperRifle, aim a bit lower to compensate initial angle shift in sniper rifle. As a result, AI seems to never fail sniper rifle shots.
unc0rr
parents:
7197
diff
changeset
|
577 |
end |
509 | 578 |
else if ((GameTicks - StartTicks) > cMaxAIThinkTime) |
7197
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
579 |
or (TurnTimeLeft <= cStopThinkTime) then |
5a9775b97c7e
- TestSniperRifle ftw (still needs some consts adjustments, because AI seems to love sniper rifle too much)
unc0rr
parents:
7178
diff
changeset
|
580 |
StopThinking:= true |
369 | 581 |
end; |
4 | 582 |
|
3038 | 583 |
procedure initModule; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset
|
584 |
begin |
6982 | 585 |
StartTicks:= 0; |
8865 | 586 |
ThinkThread:= nil; |
8908
d3033e3a4113
let's try to kill the thread right away and protect the thread variable with a mutex
koda
parents:
8884
diff
changeset
|
587 |
ThreadLock:= SDL_CreateMutex(); |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset
|
588 |
end; |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset
|
589 |
|
3038 | 590 |
procedure freeModule; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset
|
591 |
begin |
7026
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6992
diff
changeset
|
592 |
FreeActionsList(); |
8908
d3033e3a4113
let's try to kill the thread right away and protect the thread variable with a mutex
koda
parents:
8884
diff
changeset
|
593 |
SDL_DestroyMutex(ThreadLock); |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset
|
594 |
end; |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset
|
595 |
|
4 | 596 |
end. |