author | unc0rr |
Fri, 25 May 2012 15:35:48 +0400 | |
changeset 7132 | baf3351646f4 |
parent 7078 | a3408d9ba5ad |
child 7164 | fad64b97947e |
permissions | -rw-r--r-- |
4 | 1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
6700 | 3 |
* Copyright (c) 2004-2012 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 |
|
16 |
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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, |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
33 |
uAmmos, SysUtils{$IFNDEF USE_SDLTHREADS} {$IFDEF UNIX}, cthreads{$ENDIF} {$ENDIF}, uTypes, |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
34 |
uVariables, uCommands, uUtils, uDebug; |
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; |
6462 | 39 |
{$IFDEF USE_SDLTHREADS} |
5504 | 40 |
ThinkThread: PSDL_Thread = nil; |
6460 | 41 |
{$ELSE} |
42 |
ThinkThread: TThreadID; |
|
43 |
{$ENDIF} |
|
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset
|
44 |
hasThread: LongInt; |
7028 | 45 |
StartTicks: Longword; |
599 | 46 |
|
369 | 47 |
procedure FreeActionsList; |
64 | 48 |
begin |
7026
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6992
diff
changeset
|
49 |
AddFileLog('FreeActionsList called'); |
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6992
diff
changeset
|
50 |
if hasThread <> 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
|
51 |
begin |
7026
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6992
diff
changeset
|
52 |
AddFileLog('Waiting AI thread to finish'); |
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6992
diff
changeset
|
53 |
StopThinking:= true; |
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6992
diff
changeset
|
54 |
repeat |
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6992
diff
changeset
|
55 |
SDL_Delay(10) |
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6992
diff
changeset
|
56 |
until hasThread = 0 |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
57 |
end; |
434 | 58 |
|
7026
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6992
diff
changeset
|
59 |
with CurrentHedgehog^ do |
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6992
diff
changeset
|
60 |
if Gear <> nil then |
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6992
diff
changeset
|
61 |
if BotLevel <> 0 then |
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6992
diff
changeset
|
62 |
StopMessages(Gear^.Message); |
740 | 63 |
|
7026
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6992
diff
changeset
|
64 |
BestActions.Count:= 0; |
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6992
diff
changeset
|
65 |
BestActions.Pos:= 0 |
369 | 66 |
end; |
67 |
||
6392 | 68 |
|
69 |
||
70 |
const cBranchStackSize = 12; |
|
71 |
type TStackEntry = record |
|
72 |
WastedTicks: Longword; |
|
73 |
MadeActions: TActions; |
|
74 |
Hedgehog: TGear; |
|
75 |
end; |
|
76 |
||
77 |
var Stack: record |
|
78 |
Count: Longword; |
|
79 |
States: array[0..Pred(cBranchStackSize)] of TStackEntry; |
|
80 |
end; |
|
81 |
||
82 |
function Push(Ticks: Longword; const Actions: TActions; const Me: TGear; Dir: integer): boolean; |
|
83 |
var bRes: boolean; |
|
84 |
begin |
|
85 |
bRes:= (Stack.Count < cBranchStackSize) and (Actions.Count < MAXACTIONS - 5); |
|
86 |
if bRes then |
|
87 |
with Stack.States[Stack.Count] do |
|
88 |
begin |
|
89 |
WastedTicks:= Ticks; |
|
90 |
MadeActions:= Actions; |
|
91 |
Hedgehog:= Me; |
|
92 |
Hedgehog.Message:= Dir; |
|
93 |
inc(Stack.Count) |
|
94 |
end; |
|
95 |
Push:= bRes |
|
96 |
end; |
|
97 |
||
98 |
procedure Pop(var Ticks: Longword; var Actions: TActions; var Me: TGear); |
|
99 |
begin |
|
100 |
dec(Stack.Count); |
|
101 |
with Stack.States[Stack.Count] do |
|
102 |
begin |
|
103 |
Ticks:= WastedTicks; |
|
104 |
Actions:= MadeActions; |
|
105 |
Me:= Hedgehog |
|
106 |
end |
|
107 |
end; |
|
108 |
||
109 |
||
110 |
||
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
542
diff
changeset
|
111 |
procedure TestAmmos(var Actions: TActions; Me: PGear; isMoved: boolean); |
3407 | 112 |
var BotLevel: Byte; |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
542
diff
changeset
|
113 |
ap: TAttackParams; |
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
542
diff
changeset
|
114 |
Score, i: LongInt; |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
115 |
a, aa: TAmmoType; |
4 | 116 |
begin |
4372 | 117 |
BotLevel:= Me^.Hedgehog^.BotLevel; |
7078
a3408d9ba5ad
AI can't use cWindSpeedf since it now does a smooth transition
nemo
parents:
7028
diff
changeset
|
118 |
windSpeed:= hwFloat2Float(cWindSpeed); |
433 | 119 |
|
64 | 120 |
for i:= 0 to Pred(Targets.Count) do |
509 | 121 |
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
|
122 |
begin |
6748 | 123 |
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
|
124 |
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
|
125 |
aa:= a; |
6460 | 126 |
{$IFDEF USE_SDLTHREADS} |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
127 |
SDL_delay(0); //ThreadSwitch was only a hint |
6460 | 128 |
{$ELSE} |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
129 |
ThreadSwitch(); |
6460 | 130 |
{$ENDIF} |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
131 |
repeat |
543
465e2ec8f05f
- Better randomness of placing hedgehogs on the land
unc0rr
parents:
542
diff
changeset
|
132 |
if (CanUseAmmo[a]) and |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
133 |
((not isMoved) or ((AmmoTests[a].flags and amtest_OnTurn) = 0)) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
134 |
begin |
3407 | 135 |
{$HINTS OFF} |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
136 |
Score:= AmmoTests[a].proc(Me, Targets.ar[i].Point, BotLevel, ap); |
3407 | 137 |
{$HINTS ON} |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
138 |
if Actions.Score + Score > BestActions.Score then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
139 |
if (BestActions.Score < 0) or (Actions.Score + Score > BestActions.Score + Byte(BotLevel) * 2048) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
140 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
141 |
BestActions:= Actions; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
142 |
inc(BestActions.Score, Score); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
143 |
BestActions.isWalkingToABetterPlace:= false; |
194 | 144 |
|
7132 | 145 |
AddAction(BestActions, aia_Weapon, Longword(a), 300 + random(400), 0, 0); |
5162 | 146 |
|
7132 | 147 |
if (ap.Angle > 0) then |
148 |
AddAction(BestActions, aia_LookRight, 0, 200, 0, 0) |
|
149 |
else if (ap.Angle < 0) then |
|
150 |
AddAction(BestActions, aia_LookLeft, 0, 200, 0, 0); |
|
151 |
||
152 |
if (ap.Time <> 0) then |
|
153 |
AddAction(BestActions, aia_Timer, ap.Time div 1000, 400, 0, 0); |
|
154 |
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
|
155 |
begin |
7132 | 156 |
ap.Angle:= LongInt(Me^.Angle) - Abs(ap.Angle); |
157 |
if ap.Angle > 0 then |
|
158 |
begin |
|
159 |
AddAction(BestActions, aia_Up, aim_push, 300 + random(250), 0, 0); |
|
160 |
AddAction(BestActions, aia_Up, aim_release, ap.Angle, 0, 0) |
|
161 |
end |
|
162 |
else if ap.Angle < 0 then |
|
163 |
begin |
|
164 |
AddAction(BestActions, aia_Down, aim_push, 300 + random(250), 0, 0); |
|
165 |
AddAction(BestActions, aia_Down, aim_release, -ap.Angle, 0, 0) |
|
166 |
end |
|
167 |
end; |
|
168 |
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
|
169 |
begin |
7132 | 170 |
AddAction(BestActions, aia_Put, 0, 1, ap.AttackPutX, ap.AttackPutY) |
171 |
end; |
|
172 |
if (Ammoz[a].Ammo.Propz and ammoprop_AttackingPut) = 0 then |
|
173 |
begin |
|
174 |
AddAction(BestActions, aia_attack, aim_push, 650 + random(300), 0, 0); |
|
175 |
AddAction(BestActions, aia_attack, aim_release, ap.Power, 0, 0); |
|
176 |
end; |
|
177 |
if ap.ExplR > 0 then |
|
178 |
AddAction(BestActions, aia_AwareExpl, ap.ExplR, 10, ap.ExplX, ap.ExplY); |
|
179 |
end |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
180 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
181 |
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
|
182 |
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
|
183 |
else inc(a) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
184 |
until (a = aa) or (CurrentHedgehog^.MultiShootAttacks > 0) or // shooting same weapon |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
185 |
StopThinking |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
186 |
end |
64 | 187 |
end; |
4 | 188 |
|
6393 | 189 |
procedure Walk(Me: PGear; var Actions: TActions); |
80 | 190 |
const FallPixForBranching = cHHRadius * 2 + 8; |
6393 | 191 |
var |
3407 | 192 |
ticks, maxticks, steps, tmp: Longword; |
433 | 193 |
BaseRate, BestRate, Rate: integer; |
75 | 194 |
GoInfo: TGoInfo; |
80 | 195 |
CanGo: boolean; |
196 |
AltMe: TGear; |
|
3407 | 197 |
BotLevel: Byte; |
6392 | 198 |
a: TAmmoType; |
64 | 199 |
begin |
3407 | 200 |
ticks:= 0; // avoid compiler hint |
433 | 201 |
Stack.Count:= 0; |
6392 | 202 |
|
203 |
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
|
204 |
CanUseAmmo[a]:= Assigned(AmmoTests[a].proc) and (HHHasAmmo(Me^.Hedgehog^, a) > 0); |
6392 | 205 |
|
4372 | 206 |
BotLevel:= Me^.Hedgehog^.BotLevel; |
75 | 207 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
208 |
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
|
209 |
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
|
210 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
211 |
maxticks:= TurnTimeLeft; |
75 | 212 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
213 |
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
|
214 |
TestAmmos(Actions, Me, false); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
215 |
|
433 | 216 |
BestRate:= RatePlace(Me); |
4374 | 217 |
BaseRate:= Max(BestRate, 0); |
75 | 218 |
|
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
|
219 |
if (Ammoz[Me^.Hedgehog^.CurAmmoType].Ammo.Propz and ammoprop_NeedTarget) <> 0 then |
7132 | 220 |
AddAction(Actions, aia_Weapon, Longword(amSkip), 100 + random(200), 0, 0); |
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
|
221 |
|
7132 | 222 |
tmp:= random(2) + 1; |
223 |
Push(0, Actions, Me^, tmp); |
|
224 |
Push(0, Actions, Me^, tmp xor 3); |
|
225 |
||
2605 | 226 |
while (Stack.Count > 0) and (not StopThinking) and (GameFlags and gfArtillery = 0) do |
433 | 227 |
begin |
228 |
Pop(ticks, Actions, Me^); |
|
193 | 229 |
|
433 | 230 |
AddAction(Actions, Me^.Message, aim_push, 250, 0, 0); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
231 |
if (Me^.Message and gmLeft) <> 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
232 |
AddAction(Actions, aia_WaitXL, hwRound(Me^.X), 0, 0, 0) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
233 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
234 |
AddAction(Actions, aia_WaitXR, hwRound(Me^.X), 0, 0, 0); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
235 |
|
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
236 |
steps:= 0; |
82 | 237 |
|
5600
c6da15eddab3
Remove PosInStack function, as bots behave better (they search more positions) without it
unc0rr
parents:
5396
diff
changeset
|
238 |
while (not StopThinking) do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
239 |
begin |
3407 | 240 |
{$HINTS OFF} |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
241 |
CanGo:= HHGo(Me, @AltMe, GoInfo); |
3407 | 242 |
{$HINTS ON} |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
243 |
inc(ticks, GoInfo.Ticks); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
244 |
if ticks > maxticks then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
245 |
break; |
194 | 246 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
247 |
if (BotLevel < 5) and (GoInfo.JumpType = jmpHJump) then // hjump support |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
248 |
if Push(ticks, Actions, AltMe, Me^.Message) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
249 |
with Stack.States[Pred(Stack.Count)] do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
250 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
251 |
if Me^.dX.isNegative then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
252 |
AddAction(MadeActions, aia_LookRight, 0, 200, 0, 0) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
253 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
254 |
AddAction(MadeActions, aia_LookLeft, 0, 200, 0, 0); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
255 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
256 |
AddAction(MadeActions, aia_HJump, 0, 305 + random(50), 0, 0); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
257 |
AddAction(MadeActions, aia_HJump, 0, 350, 0, 0); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
258 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
259 |
if Me^.dX.isNegative then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
260 |
AddAction(MadeActions, aia_LookLeft, 0, 200, 0, 0) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
261 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
262 |
AddAction(MadeActions, aia_LookRight, 0, 200, 0, 0); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
263 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
264 |
if (BotLevel < 3) and (GoInfo.JumpType = jmpLJump) then // ljump support |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
265 |
if Push(ticks, Actions, AltMe, Me^.Message) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
266 |
with Stack.States[Pred(Stack.Count)] do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
267 |
AddAction(MadeActions, aia_LJump, 0, 305 + random(50), 0, 0); |
433 | 268 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
269 |
if not CanGo then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
270 |
break; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
271 |
inc(steps); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
272 |
Actions.actions[Pred(Actions.Count)].Param:= hwRound(Me^.X); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
273 |
Rate:= RatePlace(Me); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
274 |
if Rate > BestRate then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
275 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
276 |
BestActions:= Actions; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
277 |
BestActions.isWalkingToABetterPlace:= true; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
278 |
BestRate:= Rate; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
279 |
Me^.State:= Me^.State or gstAttacked // we have better place, go there and do not use ammo |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
280 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
281 |
else if Rate < BestRate then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
282 |
break; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
283 |
if ((Me^.State and gstAttacked) = 0) and ((steps mod 4) = 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
284 |
TestAmmos(Actions, Me, true); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
285 |
if GoInfo.FallPix >= FallPixForBranching then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
286 |
Push(ticks, Actions, Me^, Me^.Message xor 3); // aia_Left xor 3 = aia_Right |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
287 |
end; |
193 | 288 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
289 |
if BestRate > BaseRate then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
290 |
exit |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
291 |
end |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
292 |
end; |
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
293 |
|
508 | 294 |
function Think(Me: Pointer): ptrint; |
74 | 295 |
var BackMe, WalkMe: TGear; |
6992 | 296 |
switchCount: LongInt; |
297 |
StartTicks, 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
|
298 |
switchImmediatelyAvailable: boolean; |
6393 | 299 |
Actions: TActions; |
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
300 |
begin |
509 | 301 |
InterlockedIncrement(hasThread); |
433 | 302 |
StartTicks:= GameTicks; |
6393 | 303 |
currHedgehogIndex:= CurrentTeam^.CurrHedgehog; |
304 |
itHedgehog:= currHedgehogIndex; |
|
305 |
switchesNum:= 0; |
|
306 |
||
307 |
switchImmediatelyAvailable:= (CurAmmoGear <> nil) and (CurAmmoGear^.Kind = gtSwitcher); |
|
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
|
308 |
switchCount:= HHHasAmmo(PGear(Me)^.Hedgehog^, amSwitch); |
509 | 309 |
|
500 | 310 |
if (PGear(Me)^.State and gstAttacked) = 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
|
311 |
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
|
312 |
begin |
6393 | 313 |
// iterate over current team hedgehogs |
314 |
repeat |
|
315 |
WalkMe:= CurrentTeam^.Hedgehogs[itHedgehog].Gear^; |
|
316 |
||
317 |
Actions.Count:= 0; |
|
318 |
Actions.Pos:= 0; |
|
319 |
Actions.Score:= 0; |
|
320 |
if switchesNum > 0 then |
|
321 |
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
|
322 |
if not switchImmediatelyAvailable then |
6393 | 323 |
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
|
324 |
// when AI has to use switcher, make it cost smth unless they have a lot of switches |
6992 | 325 |
if (switchCount < 10) then Actions.Score:= (-27+switchCount*3)*4000; |
6393 | 326 |
AddAction(Actions, aia_Weapon, Longword(amSwitch), 300 + random(200), 0, 0); |
327 |
AddAction(Actions, aia_attack, aim_push, 300 + random(300), 0, 0); |
|
328 |
AddAction(Actions, aia_attack, aim_release, 1, 0, 0); |
|
329 |
end; |
|
330 |
for i:= 1 to switchesNum do |
|
331 |
AddAction(Actions, aia_Switch, 0, 300 + random(200), 0, 0); |
|
332 |
end; |
|
333 |
Walk(@WalkMe, Actions); |
|
334 |
||
335 |
// find another hog in team |
|
336 |
repeat |
|
337 |
itHedgehog:= Succ(itHedgehog) mod CurrentTeam^.HedgehogsNumber; |
|
338 |
until (itHedgehog = currHedgehogIndex) or (CurrentTeam^.Hedgehogs[itHedgehog].Gear <> nil); |
|
339 |
||
6748 | 340 |
|
6393 | 341 |
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
|
342 |
until (not (switchImmediatelyAvailable or (switchCount > 0))) |
6393 | 343 |
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
|
344 |
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
|
345 |
or BestActions.isWalkingToABetterPlace; |
6393 | 346 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
347 |
if (StartTicks > GameTicks - 1500) and (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
|
348 |
SDL_Delay(1000); |
6393 | 349 |
|
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
|
350 |
if (BestActions.Score < -1023) and (not BestActions.isWalkingToABetterPlace) then |
6393 | 351 |
begin |
352 |
BestActions.Count:= 0; |
|
353 |
AddAction(BestActions, aia_Skip, 0, 250, 0, 0); |
|
354 |
end; |
|
355 |
||
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
356 |
end else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
357 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
358 |
begin |
6393 | 359 |
BackMe:= PGear(Me)^; |
360 |
while (not StopThinking) and (BestActions.Count = 0) do |
|
361 |
begin |
|
362 |
FillBonuses(true); |
|
363 |
WalkMe:= BackMe; |
|
364 |
Actions.Count:= 0; |
|
365 |
Actions.Pos:= 0; |
|
366 |
Actions.Score:= 0; |
|
367 |
Walk(@WalkMe, Actions); |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
368 |
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
|
369 |
SDL_Delay(100) |
6393 | 370 |
end |
371 |
end; |
|
372 |
||
500 | 373 |
PGear(Me)^.State:= PGear(Me)^.State and not gstHHThinking; |
509 | 374 |
Think:= 0; |
375 |
InterlockedDecrement(hasThread) |
|
66
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
376 |
end; |
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
377 |
|
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
378 |
procedure StartThink(Me: PGear); |
9643d75baf1e
Many AI improvements, bots do think in separate thread
unc0rr
parents:
64
diff
changeset
|
379 |
begin |
542 | 380 |
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
|
381 |
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
|
382 |
exit; |
506 | 383 |
|
2376 | 384 |
//DeleteCI(Me); // this might break demo |
369 | 385 |
Me^.State:= Me^.State or gstHHThinking; |
386 |
Me^.Message:= 0; |
|
509 | 387 |
|
388 |
BestActions.Count:= 0; |
|
389 |
BestActions.Pos:= 0; |
|
5163 | 390 |
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
|
391 |
BestActions.isWalkingToABetterPlace:= false; |
509 | 392 |
|
433 | 393 |
StopThinking:= false; |
394 |
ThinkingHH:= Me; |
|
509 | 395 |
|
70 | 396 |
FillTargets; |
80 | 397 |
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
|
398 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
399 |
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
|
400 |
exit |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
401 |
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
|
402 |
|
369 | 403 |
FillBonuses((Me^.State and gstAttacked) <> 0); |
4900 | 404 |
AddFileLog('Enter Think Thread'); |
6460 | 405 |
{$IFDEF USE_SDLTHREADS} |
406 |
ThinkThread := SDL_CreateThread(@Think{$IFDEF SDL13}, nil{$ENDIF}, Me); |
|
407 |
{$ELSE} |
|
6027 | 408 |
BeginThread(@Think, Me, ThinkThread); |
409 |
{$ENDIF} |
|
5504 | 410 |
AddFileLog('Thread started'); |
433 | 411 |
end; |
191
a03c2d037e24
Bots are in the same thread as game. Fixes FreePascal issues.
unc0rr
parents:
183
diff
changeset
|
412 |
|
433 | 413 |
procedure ProcessBot; |
6982 | 414 |
const cStopThinkTime = 40; |
4 | 415 |
begin |
602 | 416 |
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
|
417 |
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
|
418 |
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
|
419 |
and (TurnTimeLeft < cHedgehogTurnTime - 50) then |
433 | 420 |
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
|
421 |
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
|
422 |
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
|
423 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
424 |
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
|
425 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
426 |
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
|
427 |
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
|
428 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
429 |
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
|
430 |
exit; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
431 |
StartThink(Gear); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
432 |
StartTicks:= GameTicks |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
433 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
434 |
end else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
435 |
ProcessAction(BestActions, Gear) |
509 | 436 |
else if ((GameTicks - StartTicks) > cMaxAIThinkTime) |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6462
diff
changeset
|
437 |
or (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
|
438 |
StopThinking:= true |
369 | 439 |
end; |
4 | 440 |
|
3038 | 441 |
procedure initModule; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset
|
442 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2716
diff
changeset
|
443 |
hasThread:= 0; |
6982 | 444 |
StartTicks:= 0; |
6025
cac1d5601d7c
reviewed the build system and parts of the previous merge, performed some code cleanup
koda
parents:
5611
diff
changeset
|
445 |
ThinkThread:= ThinkThread; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset
|
446 |
end; |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset
|
447 |
|
3038 | 448 |
procedure freeModule; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset
|
449 |
begin |
7026
8d1724e1337e
split OnDestroy across the appropriate modules (this doen't cause leaks on mobile, right?)
koda
parents:
6992
diff
changeset
|
450 |
FreeActionsList(); |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset
|
451 |
end; |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset
|
452 |
|
4 | 453 |
end. |