author | unc0rr |
Sat, 26 Jun 2010 16:57:43 +0400 | |
changeset 3564 | 7c583c88327b |
parent 3407 | dcc129c4352e |
child 3697 | d5b30d6373fc |
permissions | -rw-r--r-- |
393 | 1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
883 | 3 |
* Copyright (c) 2006-2008 Andrey Korotaev <unC0Rr@gmail.com> |
393 | 4 |
* |
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 |
|
8 |
* |
|
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. |
|
13 |
* |
|
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 |
|
17 |
*) |
|
18 |
||
2630 | 19 |
{$INCLUDE "options.inc"} |
20 |
||
288 | 21 |
unit uAmmos; |
22 |
interface |
|
3033
2a8f385ab466
FillAmmoStore is reused - check for before start of play.
nemo
parents:
3030
diff
changeset
|
23 |
uses uConsts, uTeams, uStats; |
288 | 24 |
|
3038 | 25 |
procedure initModule; |
26 |
procedure freeModule; |
|
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2715
diff
changeset
|
27 |
|
3346 | 28 |
procedure AddAmmoStore; |
29 |
procedure SetAmmoLoadout(s: shortstring); |
|
30 |
procedure SetAmmoProbability(s: shortstring); |
|
31 |
procedure SetAmmoDelay(s: shortstring); |
|
32 |
procedure SetAmmoReinforcement(s: shortstring); |
|
288 | 33 |
procedure AssignStores; |
553
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
34 |
procedure AddAmmo(var Hedgehog: THedgehog; ammo: TAmmoType); |
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
35 |
function HHHasAmmo(var Hedgehog: THedgehog; Ammo: TAmmoType): boolean; |
371 | 36 |
procedure PackAmmo(Ammo: PHHAmmo; Slot: LongInt); |
534 | 37 |
procedure OnUsedAmmo(var Hedgehog: THedgehog); |
1964 | 38 |
procedure ApplyAngleBounds(var Hedgehog: THedgehog; AmmoType: TAmmoType); |
553
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
39 |
procedure ApplyAmmoChanges(var Hedgehog: THedgehog); |
1922 | 40 |
procedure SwitchNotHeldAmmo(var Hedgehog: THedgehog); |
783 | 41 |
procedure SetWeapon(weap: TAmmoType); |
1784 | 42 |
procedure DisableSomeWeapons; |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2732
diff
changeset
|
43 |
procedure ResetWeapons; |
3405 | 44 |
function GetAmmoByNum(num: Longword): PHHAmmo; |
288 | 45 |
|
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2715
diff
changeset
|
46 |
var shoppa: boolean; |
1966 | 47 |
|
288 | 48 |
implementation |
783 | 49 |
uses uMisc, uGears, uWorld, uLocale, uConsole; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2715
diff
changeset
|
50 |
|
295 | 51 |
type TAmmoCounts = array[TAmmoType] of Longword; |
288 | 52 |
var StoresList: array[0..Pred(cMaxHHs)] of PHHAmmo; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2715
diff
changeset
|
53 |
StoreCnt: Longword; |
3346 | 54 |
ammoLoadout, ammoProbability, ammoDelay, ammoReinforcement: shortstring; |
288 | 55 |
|
295 | 56 |
procedure FillAmmoStore(Ammo: PHHAmmo; var cnts: TAmmoCounts); |
288 | 57 |
var mi: array[0..cMaxSlotIndex] of byte; |
58 |
a: TAmmoType; |
|
295 | 59 |
begin |
3407 | 60 |
{$HINTS OFF} |
295 | 61 |
FillChar(mi, sizeof(mi), 0); |
3407 | 62 |
{$HINTS ON} |
295 | 63 |
FillChar(Ammo^, sizeof(Ammo^), 0); |
64 |
for a:= Low(TAmmoType) to High(TAmmoType) do |
|
2764 | 65 |
begin |
295 | 66 |
if cnts[a] > 0 then |
67 |
begin |
|
68 |
TryDo(mi[Ammoz[a].Slot] <= cMaxSlotAmmoIndex, 'Ammo slot overflow', true); |
|
351 | 69 |
Ammo^[Ammoz[a].Slot, mi[Ammoz[a].Slot]]:= Ammoz[a].Ammo; |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2732
diff
changeset
|
70 |
|
351 | 71 |
Ammo^[Ammoz[a].Slot, mi[Ammoz[a].Slot]].Count:= cnts[a]; |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2732
diff
changeset
|
72 |
Ammo^[Ammoz[a].Slot, mi[Ammoz[a].Slot]].InitialCount:= cnts[a]; |
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2732
diff
changeset
|
73 |
|
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2732
diff
changeset
|
74 |
if ((GameFlags and gfPlaceHog) <> 0) and (a = amTeleport) then |
2764 | 75 |
Ammo^[Ammoz[a].Slot, mi[Ammoz[a].Slot]].Count:= AMMO_INFINITE; |
295 | 76 |
inc(mi[Ammoz[a].Slot]) |
77 |
end |
|
3033
2a8f385ab466
FillAmmoStore is reused - check for before start of play.
nemo
parents:
3030
diff
changeset
|
78 |
else if (TotalRounds < 0) and ((GameFlags and gfPlaceHog) <> 0) and (a = amTeleport) then |
2764 | 79 |
begin |
80 |
TryDo(mi[Ammoz[a].Slot] <= cMaxSlotAmmoIndex, 'Ammo slot overflow', true); |
|
81 |
Ammo^[Ammoz[a].Slot, mi[Ammoz[a].Slot]]:= Ammoz[a].Ammo; |
|
82 |
||
2767 | 83 |
Ammo^[Ammoz[a].Slot, mi[Ammoz[a].Slot]].Count:= AMMO_INFINITE; |
2838 | 84 |
Ammo^[Ammoz[a].Slot, mi[Ammoz[a].Slot]].InitialCount:= 0; |
2764 | 85 |
|
86 |
inc(mi[Ammoz[a].Slot]) |
|
87 |
end |
|
88 |
end |
|
295 | 89 |
end; |
90 |
||
3346 | 91 |
procedure AddAmmoStore; |
3255
6d6f4241debe
Alter distribution of probabilities from frontend, allow utility crates in shoppa if probabilities permit (still ban health crates)
nemo
parents:
3114
diff
changeset
|
92 |
const probability: array [0..8] of LongWord = (0,20,30,60,100,200,400,600,800); |
295 | 93 |
var cnt: Longword; |
94 |
a: TAmmoType; |
|
95 |
ammos: TAmmoCounts; |
|
2453
fdb76012b688
Restore crate probability restriction for "shoppa" weapon sets
nemo
parents:
2434
diff
changeset
|
96 |
substr: shortstring; // TEMPORARY |
288 | 97 |
begin |
3346 | 98 |
TryDo((byte(ammoLoadout[0]) = byte(ord(High(TAmmoType)))) and (byte(ammoProbability[0]) = byte(ord(High(TAmmoType)))) and (byte(ammoDelay[0]) = byte(ord(High(TAmmoType)))) and (byte(ammoReinforcement[0]) = byte(ord(High(TAmmoType)))), 'Incomplete or missing ammo scheme set (incompatible frontend or demo/save?)', true); |
288 | 99 |
|
2453
fdb76012b688
Restore crate probability restriction for "shoppa" weapon sets
nemo
parents:
2434
diff
changeset
|
100 |
// FIXME - TEMPORARY hardcoded check on shoppa pending creation of crate *type* probability editor |
3346 | 101 |
substr:= Copy(ammoLoadout,1,15); |
2453
fdb76012b688
Restore crate probability restriction for "shoppa" weapon sets
nemo
parents:
2434
diff
changeset
|
102 |
if (substr = '000000990000009') or |
fdb76012b688
Restore crate probability restriction for "shoppa" weapon sets
nemo
parents:
2434
diff
changeset
|
103 |
(substr = '000000990000000') then |
fdb76012b688
Restore crate probability restriction for "shoppa" weapon sets
nemo
parents:
2434
diff
changeset
|
104 |
shoppa:= true; |
fdb76012b688
Restore crate probability restriction for "shoppa" weapon sets
nemo
parents:
2434
diff
changeset
|
105 |
|
288 | 106 |
inc(StoreCnt); |
107 |
TryDo(StoreCnt <= cMaxHHs, 'Ammo stores overflow', true); |
|
108 |
||
109 |
new(StoresList[Pred(StoreCnt)]); |
|
110 |
||
111 |
for a:= Low(TAmmoType) to High(TAmmoType) do |
|
112 |
begin |
|
2357
babe1a55e284
Add an empty weapon to avoid selection of weapons which aren't yet ready. Might all be useful to switch to amNothing in certain situations, like after using up all ropes, instead of bazooka.
nemo
parents:
2246
diff
changeset
|
113 |
if a <> amNothing then |
1895 | 114 |
begin |
3346 | 115 |
Ammoz[a].Probability:= probability[byte(ammoProbability[ord(a)]) - byte('0')]; |
116 |
Ammoz[a].SkipTurns:= (byte(ammoDelay[ord(a)]) - byte('0')); |
|
117 |
Ammoz[a].NumberInCase:= (byte(ammoReinforcement[ord(a)]) - byte('0')); |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
118 |
if (TrainingFlags and tfIgnoreDelays) <> 0 then Ammoz[a].SkipTurns:= 0; |
3346 | 119 |
cnt:= byte(ammoLoadout[ord(a)]) - byte('0'); |
2370 | 120 |
// avoid things we already have infinite number |
2357
babe1a55e284
Add an empty weapon to avoid selection of weapons which aren't yet ready. Might all be useful to switch to amNothing in certain situations, like after using up all ropes, instead of bazooka.
nemo
parents:
2246
diff
changeset
|
121 |
if cnt = 9 then |
babe1a55e284
Add an empty weapon to avoid selection of weapons which aren't yet ready. Might all be useful to switch to amNothing in certain situations, like after using up all ropes, instead of bazooka.
nemo
parents:
2246
diff
changeset
|
122 |
begin |
babe1a55e284
Add an empty weapon to avoid selection of weapons which aren't yet ready. Might all be useful to switch to amNothing in certain situations, like after using up all ropes, instead of bazooka.
nemo
parents:
2246
diff
changeset
|
123 |
cnt:= AMMO_INFINITE; |
2370 | 124 |
Ammoz[a].Probability:= 0 |
2357
babe1a55e284
Add an empty weapon to avoid selection of weapons which aren't yet ready. Might all be useful to switch to amNothing in certain situations, like after using up all ropes, instead of bazooka.
nemo
parents:
2246
diff
changeset
|
125 |
end; |
2860
13a53315ae18
Awesome patch from TheException - adds editing of weapon delay and crate count. Tiy might want to tweak the crate graphic, could make be smaller or less overlappy.
nemo
parents:
2855
diff
changeset
|
126 |
if Ammoz[a].NumberInCase = 0 then Ammoz[a].Probability:= 0; |
13a53315ae18
Awesome patch from TheException - adds editing of weapon delay and crate count. Tiy might want to tweak the crate graphic, could make be smaller or less overlappy.
nemo
parents:
2855
diff
changeset
|
127 |
|
2370 | 128 |
// avoid things we already have by scheme |
2461 | 129 |
// merge this into DisableSomeWeapons ? |
2357
babe1a55e284
Add an empty weapon to avoid selection of weapons which aren't yet ready. Might all be useful to switch to amNothing in certain situations, like after using up all ropes, instead of bazooka.
nemo
parents:
2246
diff
changeset
|
130 |
if ((a = amLowGravity) and ((GameFlags and gfLowGravity) <> 0)) or |
babe1a55e284
Add an empty weapon to avoid selection of weapons which aren't yet ready. Might all be useful to switch to amNothing in certain situations, like after using up all ropes, instead of bazooka.
nemo
parents:
2246
diff
changeset
|
131 |
((a = amInvulnerable) and ((GameFlags and gfInvulnerable) <> 0)) or |
babe1a55e284
Add an empty weapon to avoid selection of weapons which aren't yet ready. Might all be useful to switch to amNothing in certain situations, like after using up all ropes, instead of bazooka.
nemo
parents:
2246
diff
changeset
|
132 |
((a = amLaserSight) and ((GameFlags and gfLaserSight) <> 0)) or |
babe1a55e284
Add an empty weapon to avoid selection of weapons which aren't yet ready. Might all be useful to switch to amNothing in certain situations, like after using up all ropes, instead of bazooka.
nemo
parents:
2246
diff
changeset
|
133 |
((a = amVampiric) and ((GameFlags and gfVampiric) <> 0)) then |
2128 | 134 |
begin |
2357
babe1a55e284
Add an empty weapon to avoid selection of weapons which aren't yet ready. Might all be useful to switch to amNothing in certain situations, like after using up all ropes, instead of bazooka.
nemo
parents:
2246
diff
changeset
|
135 |
cnt:= 0; |
2370 | 136 |
Ammoz[a].Probability:= 0 |
137 |
end; |
|
2457
ecf0c7e7995b
Initial molotov cocktail. Still needs graphics, tweaking of fire behaviour. Also changed probabilities for default weapon sets
nemo
parents:
2453
diff
changeset
|
138 |
ammos[a]:= cnt; |
2730
f56592281526
Remove king invulnerability, disable everything but teleport instead.
nemo
parents:
2716
diff
changeset
|
139 |
|
2769
82bfcc006afb
Some handling of interaction between king mode and place hogs mode.
nemo
parents:
2767
diff
changeset
|
140 |
if ((GameFlags and gfKing) <> 0) and ((GameFlags and gfPlaceHog) = 0) and (Ammoz[a].SkipTurns = 0) and (a <> amTeleport) and (a <> amSkip) then |
2732
d893901eff4a
Only add turn timeout for weapons that don't already have a timeout
nemo
parents:
2731
diff
changeset
|
141 |
Ammoz[a].SkipTurns:= 1; |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2732
diff
changeset
|
142 |
|
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2732
diff
changeset
|
143 |
if ((GameFlags and gfPlaceHog) <> 0) and |
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2732
diff
changeset
|
144 |
(a <> amTeleport) and (a <> amSkip) and |
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2732
diff
changeset
|
145 |
(Ammoz[a].SkipTurns < 10000) then inc(Ammoz[a].SkipTurns,10000) |
2360
d4d545da9dbe
Ok. This time I think I have it. amNothing should work.
nemo
parents:
2357
diff
changeset
|
146 |
end else |
2370 | 147 |
ammos[a]:= AMMO_INFINITE |
288 | 148 |
end; |
295 | 149 |
|
150 |
FillAmmoStore(StoresList[Pred(StoreCnt)], ammos) |
|
288 | 151 |
end; |
152 |
||
153 |
function GetAmmoByNum(num: Longword): PHHAmmo; |
|
154 |
begin |
|
155 |
TryDo(num < StoreCnt, 'Invalid store number', true); |
|
351 | 156 |
exit(StoresList[num]) |
288 | 157 |
end; |
158 |
||
159 |
procedure AssignStores; |
|
547 | 160 |
var t: LongInt; |
288 | 161 |
i: Longword; |
162 |
begin |
|
547 | 163 |
for t:= 0 to Pred(TeamsCount) do |
164 |
with TeamsArray[t]^ do |
|
288 | 165 |
begin |
166 |
for i:= 0 to cMaxHHIndex do |
|
547 | 167 |
if Hedgehogs[i].Gear <> nil then |
168 |
Hedgehogs[i].Ammo:= GetAmmoByNum(Hedgehogs[i].AmmoStore); |
|
288 | 169 |
end |
170 |
end; |
|
171 |
||
553
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
172 |
procedure AddAmmo(var Hedgehog: THedgehog; ammo: TAmmoType); |
295 | 173 |
var ammos: TAmmoCounts; |
371 | 174 |
slot, ami: LongInt; |
295 | 175 |
hhammo: PHHAmmo; |
176 |
begin |
|
3407 | 177 |
{$HINTS OFF} |
295 | 178 |
FillChar(ammos, sizeof(ammos), 0); |
3407 | 179 |
{$HINTS ON} |
553
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
180 |
hhammo:= Hedgehog.Ammo; |
295 | 181 |
|
182 |
for slot:= 0 to cMaxSlotIndex do |
|
183 |
for ami:= 0 to cMaxSlotAmmoIndex do |
|
351 | 184 |
if hhammo^[slot, ami].Count > 0 then |
185 |
ammos[hhammo^[slot, ami].AmmoType]:= hhammo^[slot, ami].Count; |
|
295 | 186 |
|
941
b5222ddafe1f
- Fix bug with picking up ammos from cases, when total ammo count may become more than AMMO_INFINITE
unc0rr
parents:
927
diff
changeset
|
187 |
if ammos[ammo] <> AMMO_INFINITE then |
b5222ddafe1f
- Fix bug with picking up ammos from cases, when total ammo count may become more than AMMO_INFINITE
unc0rr
parents:
927
diff
changeset
|
188 |
begin |
b5222ddafe1f
- Fix bug with picking up ammos from cases, when total ammo count may become more than AMMO_INFINITE
unc0rr
parents:
927
diff
changeset
|
189 |
inc(ammos[ammo], Ammoz[ammo].NumberInCase); |
b5222ddafe1f
- Fix bug with picking up ammos from cases, when total ammo count may become more than AMMO_INFINITE
unc0rr
parents:
927
diff
changeset
|
190 |
if ammos[ammo] > AMMO_INFINITE then ammos[ammo]:= AMMO_INFINITE |
b5222ddafe1f
- Fix bug with picking up ammos from cases, when total ammo count may become more than AMMO_INFINITE
unc0rr
parents:
927
diff
changeset
|
191 |
end; |
b5222ddafe1f
- Fix bug with picking up ammos from cases, when total ammo count may become more than AMMO_INFINITE
unc0rr
parents:
927
diff
changeset
|
192 |
|
295 | 193 |
FillAmmoStore(hhammo, ammos) |
194 |
end; |
|
195 |
||
371 | 196 |
procedure PackAmmo(Ammo: PHHAmmo; Slot: LongInt); |
197 |
var ami: LongInt; |
|
295 | 198 |
b: boolean; |
199 |
begin |
|
200 |
repeat |
|
201 |
b:= false; |
|
202 |
ami:= 0; |
|
203 |
while (not b) and (ami < cMaxSlotAmmoIndex) do |
|
351 | 204 |
if (Ammo^[Slot, ami].Count = 0) |
205 |
and (Ammo^[Slot, ami + 1].Count > 0) then b:= true |
|
553
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
206 |
else inc(ami); |
2221 | 207 |
if b then // there is a free item in ammo stack |
295 | 208 |
begin |
351 | 209 |
Ammo^[Slot, ami]:= Ammo^[Slot, ami + 1]; |
210 |
Ammo^[Slot, ami + 1].Count:= 0 |
|
295 | 211 |
end; |
212 |
until not b; |
|
213 |
end; |
|
214 |
||
534 | 215 |
procedure OnUsedAmmo(var Hedgehog: THedgehog); |
295 | 216 |
begin |
534 | 217 |
with Hedgehog do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
218 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
219 |
MultiShootAttacks:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
220 |
with Ammo^[CurSlot, CurAmmo] do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
221 |
if Count <> AMMO_INFINITE then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
222 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
223 |
dec(Count); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
224 |
if Count = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
225 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
226 |
PackAmmo(Ammo, CurSlot); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
227 |
SwitchNotHeldAmmo(Hedgehog) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
228 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
229 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
230 |
end |
295 | 231 |
end; |
232 |
||
553
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
233 |
function HHHasAmmo(var Hedgehog: THedgehog; Ammo: TAmmoType): boolean; |
371 | 234 |
var slot, ami: LongInt; |
295 | 235 |
begin |
236 |
Slot:= Ammoz[Ammo].Slot; |
|
237 |
ami:= 0; |
|
351 | 238 |
while (ami <= cMaxSlotAmmoIndex) do |
295 | 239 |
begin |
553
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
240 |
with Hedgehog.Ammo^[Slot, ami] do |
941
b5222ddafe1f
- Fix bug with picking up ammos from cases, when total ammo count may become more than AMMO_INFINITE
unc0rr
parents:
927
diff
changeset
|
241 |
if (AmmoType = Ammo) then |
b5222ddafe1f
- Fix bug with picking up ammos from cases, when total ammo count may become more than AMMO_INFINITE
unc0rr
parents:
927
diff
changeset
|
242 |
exit((Count > 0) and (Hedgehog.Team^.Clan^.TurnNumber > Ammoz[AmmoType].SkipTurns)); |
295 | 243 |
inc(ami) |
351 | 244 |
end; |
245 |
HHHasAmmo:= false |
|
295 | 246 |
end; |
247 |
||
1964 | 248 |
procedure ApplyAngleBounds(var Hedgehog: THedgehog; AmmoType: TAmmoType); |
1922 | 249 |
begin |
250 |
with Hedgehog do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
251 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
252 |
CurMinAngle:= Ammoz[AmmoType].minAngle; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
253 |
if Ammoz[AmmoType].maxAngle <> 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
254 |
CurMaxAngle:= Ammoz[AmmoType].maxAngle |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
255 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
256 |
CurMaxAngle:= cMaxAngle; |
1964 | 257 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
258 |
with Hedgehog.Gear^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
259 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
260 |
if Angle < CurMinAngle then Angle:= CurMinAngle; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
261 |
if Angle > CurMaxAngle then Angle:= CurMaxAngle; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
262 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
263 |
end |
1922 | 264 |
end; |
265 |
||
2432
1a0bb82d55f0
Switch to first legal ammo when hedgehog can't hold current one
unc0rr
parents:
2431
diff
changeset
|
266 |
procedure SwitchToFirstLegalAmmo(var Hedgehog: THedgehog); |
1a0bb82d55f0
Switch to first legal ammo when hedgehog can't hold current one
unc0rr
parents:
2431
diff
changeset
|
267 |
begin |
1a0bb82d55f0
Switch to first legal ammo when hedgehog can't hold current one
unc0rr
parents:
2431
diff
changeset
|
268 |
with Hedgehog do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
269 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
270 |
CurAmmo:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
271 |
CurSlot:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
272 |
while (CurSlot <= cMaxSlotIndex) and |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
273 |
((Ammo^[CurSlot, CurAmmo].Count = 0) or |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
274 |
(Ammoz[Ammo^[CurSlot, CurAmmo].AmmoType].SkipTurns - CurrentTeam^.Clan^.TurnNumber >= 0)) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
275 |
do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
276 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
277 |
while (CurAmmo <= cMaxSlotAmmoIndex) and |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
278 |
((Ammo^[CurSlot, CurAmmo].Count = 0) or |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
279 |
(Ammoz[Ammo^[CurSlot, CurAmmo].AmmoType].SkipTurns - CurrentTeam^.Clan^.TurnNumber >= 0)) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
280 |
do inc(CurAmmo); |
2432
1a0bb82d55f0
Switch to first legal ammo when hedgehog can't hold current one
unc0rr
parents:
2431
diff
changeset
|
281 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
282 |
if (CurAmmo > cMaxSlotAmmoIndex) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
283 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
284 |
CurAmmo:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
285 |
inc(CurSlot) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
286 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
287 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
288 |
TryDo(CurSlot <= cMaxSlotIndex, 'Ammo slot index overflow', true) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
289 |
end |
2432
1a0bb82d55f0
Switch to first legal ammo when hedgehog can't hold current one
unc0rr
parents:
2431
diff
changeset
|
290 |
end; |
1a0bb82d55f0
Switch to first legal ammo when hedgehog can't hold current one
unc0rr
parents:
2431
diff
changeset
|
291 |
|
553
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
292 |
procedure ApplyAmmoChanges(var Hedgehog: THedgehog); |
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
293 |
var s: shortstring; |
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
294 |
begin |
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
295 |
TargetPoint.X:= NoPointX; |
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
296 |
|
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
297 |
with Hedgehog do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
298 |
begin |
3030 | 299 |
Timer:= 10; |
2409
dbf195c3e09c
fix a very rare bug in which CurSlot becomes greater than cMaxCurSlot
koda
parents:
2370
diff
changeset
|
300 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
301 |
if (Ammo^[CurSlot, CurAmmo].Count = 0) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
302 |
SwitchToFirstLegalAmmo(Hedgehog); |
2431
23242609c44b
Real fix to ammo slot overflow (bug triggered by r2411 fix)
unc0rr
parents:
2409
diff
changeset
|
303 |
|
2409
dbf195c3e09c
fix a very rare bug in which CurSlot becomes greater than cMaxCurSlot
koda
parents:
2370
diff
changeset
|
304 |
//bad things could happen here in case CurSlot is overflowing |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
305 |
ApplyAngleBounds(Hedgehog, Ammo^[CurSlot, CurAmmo].AmmoType); |
553
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
306 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
307 |
with Ammo^[CurSlot, CurAmmo] do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
308 |
begin |
2357
babe1a55e284
Add an empty weapon to avoid selection of weapons which aren't yet ready. Might all be useful to switch to amNothing in certain situations, like after using up all ropes, instead of bazooka.
nemo
parents:
2246
diff
changeset
|
309 |
if AmmoType <> amNothing then |
babe1a55e284
Add an empty weapon to avoid selection of weapons which aren't yet ready. Might all be useful to switch to amNothing in certain situations, like after using up all ropes, instead of bazooka.
nemo
parents:
2246
diff
changeset
|
310 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
311 |
s:= trammo[Ammoz[AmmoType].NameId]; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
312 |
if (Count <> AMMO_INFINITE) and not (Hedgehog.Team^.ExtDriven or (Hedgehog.BotLevel > 0)) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
313 |
s:= s + ' (' + IntToStr(Count) + ')'; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
314 |
if (Propz and ammoprop_Timerable) <> 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
315 |
s:= s + ', ' + inttostr(Timer div 1000) + ' ' + trammo[sidSeconds]; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
316 |
AddCaption(s, Team^.Clan^.Color, capgrpAmmoinfo); |
2357
babe1a55e284
Add an empty weapon to avoid selection of weapons which aren't yet ready. Might all be useful to switch to amNothing in certain situations, like after using up all ropes, instead of bazooka.
nemo
parents:
2246
diff
changeset
|
317 |
end; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
318 |
if (Propz and ammoprop_NeedTarget) <> 0 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
319 |
then begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
320 |
Gear^.State:= Gear^.State or gstHHChooseTarget; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
321 |
isCursorVisible:= true |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
322 |
end else begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
323 |
Gear^.State:= Gear^.State and not gstHHChooseTarget; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
324 |
isCursorVisible:= false |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
325 |
end; |
3114
3a3d1ee2ebd0
Tidier way to handle crosshair drawing. show/hide based on CurAmmoGear for alt attack weps
nemo
parents:
3075
diff
changeset
|
326 |
if (CurAmmoGear <> nil) and ((CurAmmoGear^.Ammo^.Propz and ammoprop_AltAttack) <> 0) then |
3a3d1ee2ebd0
Tidier way to handle crosshair drawing. show/hide based on CurAmmoGear for alt attack weps
nemo
parents:
3075
diff
changeset
|
327 |
ShowCrosshair:= (CurAmmoGear^.Ammo^.Propz and ammoprop_NoCrossHair) = 0 |
3a3d1ee2ebd0
Tidier way to handle crosshair drawing. show/hide based on CurAmmoGear for alt attack weps
nemo
parents:
3075
diff
changeset
|
328 |
else |
3a3d1ee2ebd0
Tidier way to handle crosshair drawing. show/hide based on CurAmmoGear for alt attack weps
nemo
parents:
3075
diff
changeset
|
329 |
ShowCrosshair:= (Propz and ammoprop_NoCrosshair) = 0; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
330 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
331 |
end |
553
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
332 |
end; |
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
333 |
|
1922 | 334 |
procedure SwitchNotHeldAmmo(var Hedgehog: THedgehog); |
553
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
335 |
begin |
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
336 |
with Hedgehog do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
337 |
if ((Ammo^[CurSlot, CurAmmo].Propz and ammoprop_DontHold) <> 0) or |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
338 |
(Ammoz[Ammo^[CurSlot, CurAmmo].AmmoType].SkipTurns - CurrentTeam^.Clan^.TurnNumber >= 0) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
339 |
SwitchToFirstLegalAmmo(Hedgehog); |
553
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
340 |
end; |
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
341 |
|
783 | 342 |
procedure SetWeapon(weap: TAmmoType); |
343 |
begin |
|
1850 | 344 |
ParseCommand('/setweap ' + char(weap), true) |
783 | 345 |
end; |
346 |
||
1784 | 347 |
procedure DisableSomeWeapons; |
348 |
var i, slot, a: Longword; |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
349 |
t: TAmmoType; |
1784 | 350 |
begin |
351 |
for i:= 0 to Pred(StoreCnt) do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
352 |
for slot:= 0 to cMaxSlotIndex do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
353 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
354 |
for a:= 0 to cMaxSlotAmmoIndex do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
355 |
with StoresList[i]^[slot, a] do |
3319 | 356 |
if (Propz and ammoprop_NotBorder) <> 0 then |
357 |
begin |
|
358 |
Count:= 0; |
|
359 |
InitialCount:= 0 |
|
360 |
end; |
|
1784 | 361 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
362 |
PackAmmo(StoresList[i], slot) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
363 |
end; |
1784 | 364 |
|
365 |
for t:= Low(TAmmoType) to High(TAmmoType) do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
366 |
if (Ammoz[t].Ammo.Propz and ammoprop_NotBorder) <> 0 then Ammoz[t].Probability:= 0 |
1784 | 367 |
end; |
368 |
||
3346 | 369 |
procedure SetAmmoLoadout(s: shortstring); |
370 |
begin |
|
371 |
ammoLoadout:= s; |
|
372 |
end; |
|
373 |
||
374 |
procedure SetAmmoProbability(s: shortstring); |
|
375 |
begin |
|
376 |
ammoProbability:= s; |
|
377 |
end; |
|
378 |
||
379 |
procedure SetAmmoDelay(s: shortstring); |
|
380 |
begin |
|
381 |
ammoDelay:= s; |
|
382 |
end; |
|
383 |
||
384 |
procedure SetAmmoReinforcement(s: shortstring); |
|
385 |
begin |
|
386 |
ammoReinforcement:= s; |
|
387 |
end; |
|
388 |
||
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2732
diff
changeset
|
389 |
// Restore indefinitely disabled weapons and initial weapon counts. Only used for hog placement right now |
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2732
diff
changeset
|
390 |
procedure ResetWeapons; |
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2732
diff
changeset
|
391 |
var i, slot, a: Longword; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
392 |
t: TAmmoType; |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2732
diff
changeset
|
393 |
begin |
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2732
diff
changeset
|
394 |
for i:= 0 to Pred(StoreCnt) do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
395 |
for slot:= 0 to cMaxSlotIndex do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
396 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
397 |
for a:= 0 to cMaxSlotAmmoIndex do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
398 |
with StoresList[i]^[slot, a] do |
2818 | 399 |
Count:= InitialCount; |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2732
diff
changeset
|
400 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
401 |
PackAmmo(StoresList[i], slot) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
402 |
end; |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2732
diff
changeset
|
403 |
for t:= Low(TAmmoType) to High(TAmmoType) do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
404 |
if Ammoz[t].SkipTurns >= 10000 then dec(Ammoz[t].SkipTurns,10000); |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2732
diff
changeset
|
405 |
end; |
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2732
diff
changeset
|
406 |
|
3038 | 407 |
procedure initModule; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2715
diff
changeset
|
408 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
409 |
shoppa:= false; |
3346 | 410 |
StoreCnt:= 0; |
411 |
ammoLoadout:= ''; |
|
412 |
ammoProbability:= ''; |
|
413 |
ammoDelay:= ''; |
|
414 |
ammoReinforcement:= '' |
|
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2715
diff
changeset
|
415 |
end; |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2715
diff
changeset
|
416 |
|
3038 | 417 |
procedure freeModule; |
2715
0e4e0db79e2a
Free up some unfreed memory. Needed for Koda's iphone lib work
nemo
parents:
2630
diff
changeset
|
418 |
var i: LongWord; |
0e4e0db79e2a
Free up some unfreed memory. Needed for Koda's iphone lib work
nemo
parents:
2630
diff
changeset
|
419 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
420 |
if StoreCnt > 0 then |
3052 | 421 |
for i:= 0 to Pred(StoreCnt) do Dispose(StoresList[i]) |
2715
0e4e0db79e2a
Free up some unfreed memory. Needed for Koda's iphone lib work
nemo
parents:
2630
diff
changeset
|
422 |
end; |
0e4e0db79e2a
Free up some unfreed memory. Needed for Koda's iphone lib work
nemo
parents:
2630
diff
changeset
|
423 |
|
288 | 424 |
end. |