author | Periklis Ntanasis <pntanasis@gmail.com> |
Sat, 10 Aug 2013 04:39:47 +0300 | |
branch | spacecampaign |
changeset 9508 | c23bff98e3d2 |
parent 9080 | 9b42757d7e71 |
child 9127 | e350500c4edb |
child 9391 | 2af25494f3bb |
permissions | -rw-r--r-- |
393 | 1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
9080 | 3 |
* Copyright (c) 2004-2013 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 |
|
7754 | 23 |
uses uConsts, uTypes, uStore; |
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; |
6898 | 29 |
procedure SetAmmoLoadout(var s: shortstring); |
30 |
procedure SetAmmoProbability(var s: shortstring); |
|
31 |
procedure SetAmmoDelay(var s: shortstring); |
|
32 |
procedure SetAmmoReinforcement(var 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); |
7337
c224cd2d32f3
Allow script to set number of ammo in a crate. untested.
nemo
parents:
7037
diff
changeset
|
35 |
procedure AddAmmo(var Hedgehog: THedgehog; ammo: TAmmoType; amt: LongWord); |
6924 | 36 |
procedure SetAmmo(var Hedgehog: THedgehog; ammo: TAmmoType; cnt: 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:
6762
diff
changeset
|
37 |
function HHHasAmmo(var Hedgehog: THedgehog; Ammo: TAmmoType): LongWord; |
371 | 38 |
procedure PackAmmo(Ammo: PHHAmmo; Slot: LongInt); |
534 | 39 |
procedure OnUsedAmmo(var Hedgehog: THedgehog); |
1964 | 40 |
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
|
41 |
procedure ApplyAmmoChanges(var Hedgehog: THedgehog); |
1922 | 42 |
procedure SwitchNotHeldAmmo(var Hedgehog: THedgehog); |
783 | 43 |
procedure SetWeapon(weap: TAmmoType); |
1784 | 44 |
procedure DisableSomeWeapons; |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2732
diff
changeset
|
45 |
procedure ResetWeapons; |
3405 | 46 |
function GetAmmoByNum(num: Longword): PHHAmmo; |
6924 | 47 |
function GetCurAmmoEntry(var Hedgehog: THedgehog): PAmmo; |
5272 | 48 |
function GetAmmoEntry(var Hedgehog: THedgehog; am: TAmmoType): PAmmo; |
288 | 49 |
|
4143
eb7981f34800
Remove the last vestiges of the shoppa hack by adding 2 spinners for percentage health and amount of health in crate, also update translations and increase SD spinner (some users have requested it)
henek
parents:
4141
diff
changeset
|
50 |
var StoreCnt: Longword; |
1966 | 51 |
|
288 | 52 |
implementation |
6624
e049b5bb0ad1
BUUUUURN OBJC AMMOMENU BUUUURNhg diff! (on a separate note, this reduces the codesize by ~37k)
koda
parents:
6622
diff
changeset
|
53 |
uses uLocale, uVariables, uCommands, uUtils, uCaptions, uDebug; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2715
diff
changeset
|
54 |
|
295 | 55 |
type TAmmoCounts = array[TAmmoType] of Longword; |
288 | 56 |
var StoresList: array[0..Pred(cMaxHHs)] of PHHAmmo; |
3346 | 57 |
ammoLoadout, ammoProbability, ammoDelay, ammoReinforcement: shortstring; |
3951
c9a63db3e603
Correct another bug in slot switching, adjust width of theme list, really truly fix reset of weps (I hope) should also fix infinite teleport bug in place hogs mode. Slow update of health to 5s for inf attack mode.
nemo
parents:
3943
diff
changeset
|
58 |
InitialCounts: array[0..Pred(cMaxHHs)] of TAmmoCounts; |
288 | 59 |
|
295 | 60 |
procedure FillAmmoStore(Ammo: PHHAmmo; var cnts: TAmmoCounts); |
288 | 61 |
var mi: array[0..cMaxSlotIndex] of byte; |
62 |
a: TAmmoType; |
|
295 | 63 |
begin |
3407 | 64 |
{$HINTS OFF} |
295 | 65 |
FillChar(mi, sizeof(mi), 0); |
3407 | 66 |
{$HINTS ON} |
295 | 67 |
FillChar(Ammo^, sizeof(Ammo^), 0); |
68 |
for a:= Low(TAmmoType) to High(TAmmoType) do |
|
2764 | 69 |
begin |
295 | 70 |
if cnts[a] > 0 then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
71 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
72 |
TryDo(mi[Ammoz[a].Slot] <= cMaxSlotAmmoIndex, 'Ammo slot overflow', true); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
73 |
Ammo^[Ammoz[a].Slot, mi[Ammoz[a].Slot]]:= Ammoz[a].Ammo; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
74 |
with Ammo^[Ammoz[a].Slot, mi[Ammoz[a].Slot]] do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
75 |
Count:= cnts[a]; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
76 |
inc(mi[Ammoz[a].Slot]) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
77 |
end |
6631 | 78 |
end; |
79 |
AmmoMenuInvalidated:= true; |
|
295 | 80 |
end; |
81 |
||
3346 | 82 |
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
|
83 |
const probability: array [0..8] of LongWord = (0,20,30,60,100,200,400,600,800); |
295 | 84 |
var cnt: Longword; |
85 |
a: TAmmoType; |
|
86 |
ammos: TAmmoCounts; |
|
288 | 87 |
begin |
3346 | 88 |
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 | 89 |
|
90 |
inc(StoreCnt); |
|
91 |
TryDo(StoreCnt <= cMaxHHs, 'Ammo stores overflow', true); |
|
92 |
||
93 |
new(StoresList[Pred(StoreCnt)]); |
|
94 |
||
95 |
for a:= Low(TAmmoType) to High(TAmmoType) do |
|
96 |
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
|
97 |
if a <> amNothing then |
1895 | 98 |
begin |
3346 | 99 |
Ammoz[a].Probability:= probability[byte(ammoProbability[ord(a)]) - byte('0')]; |
100 |
Ammoz[a].SkipTurns:= (byte(ammoDelay[ord(a)]) - byte('0')); |
|
101 |
Ammoz[a].NumberInCase:= (byte(ammoReinforcement[ord(a)]) - byte('0')); |
|
102 |
cnt:= byte(ammoLoadout[ord(a)]) - byte('0'); |
|
2370 | 103 |
// 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
|
104 |
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
|
105 |
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
|
106 |
cnt:= AMMO_INFINITE; |
2370 | 107 |
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
|
108 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
109 |
if Ammoz[a].NumberInCase = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
110 |
Ammoz[a].Probability:= 0; |
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
|
111 |
|
2370 | 112 |
// avoid things we already have by scheme |
2461 | 113 |
// merge this into DisableSomeWeapons ? |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
114 |
if ((a = amLowGravity) and ((GameFlags and gfLowGravity) <> 0)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
115 |
or ((a = amInvulnerable) and ((GameFlags and gfInvulnerable) <> 0)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
116 |
or ((a = amLaserSight) and ((GameFlags and gfLaserSight) <> 0)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
117 |
or ((a = amVampiric) and ((GameFlags and gfVampiric) <> 0)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
118 |
or ((a = amExtraTime) and (cHedgehogTurnTime >= 1000000)) then |
2128 | 119 |
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
|
120 |
cnt:= 0; |
2370 | 121 |
Ammoz[a].Probability:= 0 |
122 |
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
|
123 |
ammos[a]:= cnt; |
2730
f56592281526
Remove king invulnerability, disable everything but teleport instead.
nemo
parents:
2716
diff
changeset
|
124 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
125 |
if ((GameFlags and gfKing) <> 0) and ((GameFlags and gfPlaceHog) = 0) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
126 |
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
|
127 |
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
|
128 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
129 |
if ((GameFlags and gfPlaceHog) <> 0) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
130 |
and (a <> amTeleport) and (a <> amSkip) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
131 |
and (Ammoz[a].SkipTurns < 10000) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
132 |
inc(Ammoz[a].SkipTurns,10000); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
133 |
if ((GameFlags and gfPlaceHog) <> 0) and (a = amTeleport) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
134 |
ammos[a]:= AMMO_INFINITE |
3951
c9a63db3e603
Correct another bug in slot switching, adjust width of theme list, really truly fix reset of weps (I hope) should also fix infinite teleport bug in place hogs mode. Slow update of health to 5s for inf attack mode.
nemo
parents:
3943
diff
changeset
|
135 |
end |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
136 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
137 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
138 |
ammos[a]:= AMMO_INFINITE; |
4344
23ab3bdbf218
This should fix Chip's bug with unlimited teleports. Also remove more hog placement special behaviour and just use ResetWeapons with a check against PlacingHogs mode
nemo
parents:
4339
diff
changeset
|
139 |
if ((GameFlags and gfPlaceHog) <> 0) and (a = amTeleport) then |
5345
3c5480e91951
Simplify code using 'with', convert some tabs to spaces
unc0rr
parents:
5316
diff
changeset
|
140 |
InitialCounts[Pred(StoreCnt)][a]:= cnt |
4344
23ab3bdbf218
This should fix Chip's bug with unlimited teleports. Also remove more hog placement special behaviour and just use ResetWeapons with a check against PlacingHogs mode
nemo
parents:
4339
diff
changeset
|
141 |
else |
5345
3c5480e91951
Simplify code using 'with', convert some tabs to spaces
unc0rr
parents:
5316
diff
changeset
|
142 |
InitialCounts[Pred(StoreCnt)][a]:= ammos[a]; |
288 | 143 |
end; |
295 | 144 |
FillAmmoStore(StoresList[Pred(StoreCnt)], ammos) |
288 | 145 |
end; |
146 |
||
147 |
function GetAmmoByNum(num: Longword): PHHAmmo; |
|
148 |
begin |
|
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6924
diff
changeset
|
149 |
TryDo(num < StoreCnt, 'Invalid store number', true); |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6924
diff
changeset
|
150 |
GetAmmoByNum:= StoresList[num] |
288 | 151 |
end; |
152 |
||
6924 | 153 |
function GetCurAmmoEntry(var Hedgehog: THedgehog): PAmmo; |
5272 | 154 |
begin |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6924
diff
changeset
|
155 |
GetCurAmmoEntry:= GetAmmoEntry(Hedgehog, Hedgehog.CurAmmoType) |
5272 | 156 |
end; |
157 |
||
158 |
function GetAmmoEntry(var Hedgehog: THedgehog; am: TAmmoType): PAmmo; |
|
3836
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
159 |
var ammoidx, slot: LongWord; |
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
160 |
begin |
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
161 |
with Hedgehog do |
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
162 |
begin |
5272 | 163 |
slot:= Ammoz[am].Slot; |
3836
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
164 |
ammoidx:= 0; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
165 |
while (ammoidx < cMaxSlotAmmoIndex) and (Ammo^[slot, ammoidx].AmmoType <> am) do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
166 |
inc(ammoidx); |
3836
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
167 |
GetAmmoEntry:= @Ammo^[slot, ammoidx]; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
168 |
if (Ammo^[slot, ammoidx].AmmoType <> am) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
169 |
GetAmmoEntry:= GetAmmoEntry(Hedgehog, amNothing) |
5676
a655dfab27d7
Scripting changes. Add override of mapgen, templatefilter. Expose waterline, add "GetAmmoCount". Default to amNothing in uAmmos if entry is not found.
nemo
parents:
5640
diff
changeset
|
170 |
end; |
3836
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
171 |
end; |
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
172 |
|
288 | 173 |
procedure AssignStores; |
547 | 174 |
var t: LongInt; |
288 | 175 |
i: Longword; |
176 |
begin |
|
547 | 177 |
for t:= 0 to Pred(TeamsCount) do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
178 |
with TeamsArray[t]^ do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
179 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
180 |
for i:= 0 to cMaxHHIndex do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
181 |
if Hedgehogs[i].Gear <> nil then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
182 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
183 |
Hedgehogs[i].Ammo:= GetAmmoByNum(Hedgehogs[i].AmmoStore); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
184 |
if (GameFlags and gfPlaceHog) <> 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
185 |
Hedgehogs[i].CurAmmoType:= amTeleport |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
186 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
187 |
Hedgehogs[i].CurAmmoType:= amNothing |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
188 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
189 |
end |
288 | 190 |
end; |
191 |
||
7337
c224cd2d32f3
Allow script to set number of ammo in a crate. untested.
nemo
parents:
7037
diff
changeset
|
192 |
procedure AddAmmo(var Hedgehog: THedgehog; ammo: TAmmoType; amt: LongWord); |
5273 | 193 |
var cnt: LongWord; |
5676
a655dfab27d7
Scripting changes. Add override of mapgen, templatefilter. Expose waterline, add "GetAmmoCount". Default to amNothing in uAmmos if entry is not found.
nemo
parents:
5640
diff
changeset
|
194 |
a: PAmmo; |
5272 | 195 |
begin |
5676
a655dfab27d7
Scripting changes. Add override of mapgen, templatefilter. Expose waterline, add "GetAmmoCount". Default to amNothing in uAmmos if entry is not found.
nemo
parents:
5640
diff
changeset
|
196 |
a:= GetAmmoEntry(Hedgehog, ammo); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
197 |
if (a^.AmmoType <> amNothing) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
198 |
cnt:= a^.Count |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
199 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
200 |
cnt:= 0; |
5688
fba59d6b5b6c
Correctly check for failure to look up ammo, check for damaged mines
nemo
parents:
5680
diff
changeset
|
201 |
if (cnt <> AMMO_INFINITE) then |
5273 | 202 |
begin |
7337
c224cd2d32f3
Allow script to set number of ammo in a crate. untested.
nemo
parents:
7037
diff
changeset
|
203 |
inc(cnt, amt); |
6924 | 204 |
SetAmmo(Hedgehog, ammo, cnt) |
5273 | 205 |
end |
5272 | 206 |
end; |
207 |
||
7337
c224cd2d32f3
Allow script to set number of ammo in a crate. untested.
nemo
parents:
7037
diff
changeset
|
208 |
procedure AddAmmo(var Hedgehog: THedgehog; ammo: TAmmoType); |
c224cd2d32f3
Allow script to set number of ammo in a crate. untested.
nemo
parents:
7037
diff
changeset
|
209 |
begin |
c224cd2d32f3
Allow script to set number of ammo in a crate. untested.
nemo
parents:
7037
diff
changeset
|
210 |
AddAmmo(Hedgehog, ammo, Ammoz[ammo].NumberInCase); |
c224cd2d32f3
Allow script to set number of ammo in a crate. untested.
nemo
parents:
7037
diff
changeset
|
211 |
end; |
c224cd2d32f3
Allow script to set number of ammo in a crate. untested.
nemo
parents:
7037
diff
changeset
|
212 |
|
6924 | 213 |
procedure SetAmmo(var Hedgehog: THedgehog; ammo: TAmmoType; cnt: LongWord); |
295 | 214 |
var ammos: TAmmoCounts; |
371 | 215 |
slot, ami: LongInt; |
295 | 216 |
hhammo: PHHAmmo; |
5316
191cd6c06203
Allow control of grenade bounce. Not sure if this is a good idea, but has been requested a lot, so...
nemo
parents:
5273
diff
changeset
|
217 |
CurWeapon: PAmmo; |
295 | 218 |
begin |
3407 | 219 |
{$HINTS OFF} |
295 | 220 |
FillChar(ammos, sizeof(ammos), 0); |
3407 | 221 |
{$HINTS ON} |
553
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
222 |
hhammo:= Hedgehog.Ammo; |
295 | 223 |
|
224 |
for slot:= 0 to cMaxSlotIndex do |
|
225 |
for ami:= 0 to cMaxSlotAmmoIndex do |
|
351 | 226 |
if hhammo^[slot, ami].Count > 0 then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
227 |
ammos[hhammo^[slot, ami].AmmoType]:= hhammo^[slot, ami].Count; |
295 | 228 |
|
5272 | 229 |
ammos[ammo]:= cnt; |
230 |
if ammos[ammo] > AMMO_INFINITE then ammos[ammo]:= AMMO_INFINITE; |
|
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
|
231 |
|
5316
191cd6c06203
Allow control of grenade bounce. Not sure if this is a good idea, but has been requested a lot, so...
nemo
parents:
5273
diff
changeset
|
232 |
FillAmmoStore(hhammo, ammos); |
6924 | 233 |
CurWeapon:= GetCurAmmoEntry(Hedgehog); |
5345
3c5480e91951
Simplify code using 'with', convert some tabs to spaces
unc0rr
parents:
5316
diff
changeset
|
234 |
with Hedgehog, CurWeapon^ do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
235 |
if (Count = 0) or (AmmoType = amNothing) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
236 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
237 |
PackAmmo(Ammo, Ammoz[AmmoType].Slot); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
238 |
CurAmmoType:= amNothing |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
239 |
end |
295 | 240 |
end; |
241 |
||
371 | 242 |
procedure PackAmmo(Ammo: PHHAmmo; Slot: LongInt); |
243 |
var ami: LongInt; |
|
295 | 244 |
b: boolean; |
245 |
begin |
|
246 |
repeat |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
247 |
b:= false; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
248 |
ami:= 0; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
249 |
while (not b) and (ami < cMaxSlotAmmoIndex) do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
250 |
if (Ammo^[Slot, ami].Count = 0) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
251 |
and (Ammo^[Slot, ami + 1].Count > 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
252 |
b:= true |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
253 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
254 |
inc(ami); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
255 |
if b then // there is a free item in ammo stack |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
256 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
257 |
Ammo^[Slot, ami]:= Ammo^[Slot, ami + 1]; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
258 |
Ammo^[Slot, ami + 1].Count:= 0 |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
259 |
end; |
295 | 260 |
until not b; |
6631 | 261 |
AmmoMenuInvalidated:= true; |
295 | 262 |
end; |
263 |
||
534 | 264 |
procedure OnUsedAmmo(var Hedgehog: THedgehog); |
3836
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
265 |
var CurWeapon: PAmmo; |
295 | 266 |
begin |
6924 | 267 |
CurWeapon:= GetCurAmmoEntry(Hedgehog); |
534 | 268 |
with Hedgehog do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
269 |
begin |
3836
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
270 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
271 |
MultiShootAttacks:= 0; |
3836
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
272 |
with CurWeapon^ do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
273 |
if Count <> AMMO_INFINITE then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
274 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
275 |
dec(Count); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
276 |
if Count = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
277 |
begin |
3836
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
278 |
PackAmmo(Ammo, Ammoz[AmmoType].Slot); |
3931
fd04228971b3
Set ammo to amNothing after using up the current ammo. This should reduce noob fail where they blow themselves up w/ bazooka.
nemo
parents:
3836
diff
changeset
|
279 |
//SwitchNotHeldAmmo(Hedgehog); |
7754 | 280 |
if CurAmmoType = amKnife then LoadHedgehogHat(Hedgehog, Hedgehog.Hat); |
9006
552517b23882
bleah. sorry for spam. this reverts the first attempt in uAmmos
nemo
parents:
9004
diff
changeset
|
281 |
CurAmmoType:= amNothing |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
282 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
283 |
end |
3935 | 284 |
end; |
295 | 285 |
end; |
286 |
||
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:
6762
diff
changeset
|
287 |
function HHHasAmmo(var Hedgehog: THedgehog; Ammo: TAmmoType): LongWord; |
371 | 288 |
var slot, ami: LongInt; |
295 | 289 |
begin |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6924
diff
changeset
|
290 |
HHHasAmmo:= 0; |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6924
diff
changeset
|
291 |
Slot:= Ammoz[Ammo].Slot; |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6924
diff
changeset
|
292 |
ami:= 0; |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6924
diff
changeset
|
293 |
while (ami <= cMaxSlotAmmoIndex) do |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6924
diff
changeset
|
294 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
295 |
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
|
296 |
if (AmmoType = Ammo) then |
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:
6762
diff
changeset
|
297 |
if Hedgehog.Team^.Clan^.TurnNumber > Ammoz[AmmoType].SkipTurns then |
7037 | 298 |
exit(Count) |
299 |
else |
|
300 |
exit(0); |
|
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6924
diff
changeset
|
301 |
inc(ami) |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6924
diff
changeset
|
302 |
end; |
295 | 303 |
end; |
304 |
||
1964 | 305 |
procedure ApplyAngleBounds(var Hedgehog: THedgehog; AmmoType: TAmmoType); |
1922 | 306 |
begin |
7341
d70478d265ec
Fix crash when hedgehog dies while switching from it
unc0rr
parents:
7337
diff
changeset
|
307 |
if Hedgehog.Gear <> nil then |
d70478d265ec
Fix crash when hedgehog dies while switching from it
unc0rr
parents:
7337
diff
changeset
|
308 |
with Hedgehog do |
d70478d265ec
Fix crash when hedgehog dies while switching from it
unc0rr
parents:
7337
diff
changeset
|
309 |
begin |
d70478d265ec
Fix crash when hedgehog dies while switching from it
unc0rr
parents:
7337
diff
changeset
|
310 |
CurMinAngle:= Ammoz[AmmoType].minAngle; |
d70478d265ec
Fix crash when hedgehog dies while switching from it
unc0rr
parents:
7337
diff
changeset
|
311 |
if Ammoz[AmmoType].maxAngle <> 0 then |
d70478d265ec
Fix crash when hedgehog dies while switching from it
unc0rr
parents:
7337
diff
changeset
|
312 |
CurMaxAngle:= Ammoz[AmmoType].maxAngle |
d70478d265ec
Fix crash when hedgehog dies while switching from it
unc0rr
parents:
7337
diff
changeset
|
313 |
else |
d70478d265ec
Fix crash when hedgehog dies while switching from it
unc0rr
parents:
7337
diff
changeset
|
314 |
CurMaxAngle:= cMaxAngle; |
1964 | 315 |
|
7341
d70478d265ec
Fix crash when hedgehog dies while switching from it
unc0rr
parents:
7337
diff
changeset
|
316 |
with Hedgehog.Gear^ do |
d70478d265ec
Fix crash when hedgehog dies while switching from it
unc0rr
parents:
7337
diff
changeset
|
317 |
begin |
d70478d265ec
Fix crash when hedgehog dies while switching from it
unc0rr
parents:
7337
diff
changeset
|
318 |
if Angle < CurMinAngle then |
d70478d265ec
Fix crash when hedgehog dies while switching from it
unc0rr
parents:
7337
diff
changeset
|
319 |
Angle:= CurMinAngle; |
d70478d265ec
Fix crash when hedgehog dies while switching from it
unc0rr
parents:
7337
diff
changeset
|
320 |
if Angle > CurMaxAngle then |
d70478d265ec
Fix crash when hedgehog dies while switching from it
unc0rr
parents:
7337
diff
changeset
|
321 |
Angle:= CurMaxAngle; |
d70478d265ec
Fix crash when hedgehog dies while switching from it
unc0rr
parents:
7337
diff
changeset
|
322 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
323 |
end |
1922 | 324 |
end; |
325 |
||
2432
1a0bb82d55f0
Switch to first legal ammo when hedgehog can't hold current one
unc0rr
parents:
2431
diff
changeset
|
326 |
procedure SwitchToFirstLegalAmmo(var Hedgehog: THedgehog); |
3836
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
327 |
var slot, ammoidx: LongWord; |
2432
1a0bb82d55f0
Switch to first legal ammo when hedgehog can't hold current one
unc0rr
parents:
2431
diff
changeset
|
328 |
begin |
1a0bb82d55f0
Switch to first legal ammo when hedgehog can't hold current one
unc0rr
parents:
2431
diff
changeset
|
329 |
with Hedgehog do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
330 |
begin |
3836
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
331 |
CurAmmoType:= amNothing; |
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
332 |
slot:= 0; |
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
333 |
ammoidx:= 0; |
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
334 |
while (slot <= cMaxSlotIndex) and |
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
335 |
((Ammo^[slot, ammoidx].Count = 0) or |
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
336 |
(Ammoz[Ammo^[slot, ammoidx].AmmoType].SkipTurns - CurrentTeam^.Clan^.TurnNumber >= 0)) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
337 |
do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
338 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
339 |
while (ammoidx <= cMaxSlotAmmoIndex) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
340 |
and ((Ammo^[slot, ammoidx].Count = 0) or (Ammoz[Ammo^[slot, ammoidx].AmmoType].SkipTurns - CurrentTeam^.Clan^.TurnNumber >= 0)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
341 |
do inc(ammoidx); |
2432
1a0bb82d55f0
Switch to first legal ammo when hedgehog can't hold current one
unc0rr
parents:
2431
diff
changeset
|
342 |
|
3836
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
343 |
if (ammoidx > cMaxSlotAmmoIndex) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
344 |
begin |
3836
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
345 |
ammoidx:= 0; |
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
346 |
inc(slot) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
347 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
348 |
end; |
3836
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
349 |
TryDo(slot <= cMaxSlotIndex, 'Ammo slot index overflow', true); |
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
350 |
CurAmmoType:= Ammo^[slot, ammoidx].AmmoType; |
7754 | 351 |
if CurAmmoType = amKnife then LoadHedgehogHat(Hedgehog, 'Reserved/chef') |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
352 |
end |
2432
1a0bb82d55f0
Switch to first legal ammo when hedgehog can't hold current one
unc0rr
parents:
2431
diff
changeset
|
353 |
end; |
1a0bb82d55f0
Switch to first legal ammo when hedgehog can't hold current one
unc0rr
parents:
2431
diff
changeset
|
354 |
|
553
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
355 |
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
|
356 |
var s: shortstring; |
3836
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
357 |
CurWeapon: PAmmo; |
553
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
358 |
begin |
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
359 |
TargetPoint.X:= NoPointX; |
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
360 |
|
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
361 |
with Hedgehog do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
362 |
begin |
3030 | 363 |
Timer:= 10; |
2409
dbf195c3e09c
fix a very rare bug in which CurSlot becomes greater than cMaxCurSlot
koda
parents:
2370
diff
changeset
|
364 |
|
6924 | 365 |
CurWeapon:= GetCurAmmoEntry(Hedgehog); |
3836
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
366 |
|
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
367 |
if (CurWeapon^.Count = 0) then |
6131 | 368 |
SwitchToFirstLegalAmmo(Hedgehog) |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
369 |
else if CurWeapon^.AmmoType = amNothing then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
370 |
Hedgehog.CurAmmoType:= amNothing; |
2431
23242609c44b
Real fix to ammo slot overflow (bug triggered by r2411 fix)
unc0rr
parents:
2409
diff
changeset
|
371 |
|
6924 | 372 |
CurWeapon:= GetCurAmmoEntry(Hedgehog); |
553
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
373 |
|
3836
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
374 |
ApplyAngleBounds(Hedgehog, CurWeapon^.AmmoType); |
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
375 |
|
833c0f32e326
Change all use of curslot/idx to CurAmmoType to try and avoid some bugs with use of last weapon.
nemo
parents:
3697
diff
changeset
|
376 |
with CurWeapon^ do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
377 |
begin |
4807
180dbfb13903
display caption for ammotype amNothing when switched to so that players know what just happened
sheepluva
parents:
4403
diff
changeset
|
378 |
s:= trammo[Ammoz[AmmoType].NameId]; |
7426
55b49cc1f33a
Changes for the benefit of pas2c. Use downto in for loops to avoid repeated calls of Random/GetRandom. Wrap nots.
nemo
parents:
7341
diff
changeset
|
379 |
if (Count <> AMMO_INFINITE) and (not (Hedgehog.Team^.ExtDriven or (Hedgehog.BotLevel > 0))) then |
4807
180dbfb13903
display caption for ammotype amNothing when switched to so that players know what just happened
sheepluva
parents:
4403
diff
changeset
|
380 |
s:= s + ' (' + IntToStr(Count) + ')'; |
180dbfb13903
display caption for ammotype amNothing when switched to so that players know what just happened
sheepluva
parents:
4403
diff
changeset
|
381 |
if (Propz and ammoprop_Timerable) <> 0 then |
180dbfb13903
display caption for ammotype amNothing when switched to so that players know what just happened
sheepluva
parents:
4403
diff
changeset
|
382 |
s:= s + ', ' + IntToStr(Timer div 1000) + ' ' + trammo[sidSeconds]; |
180dbfb13903
display caption for ammotype amNothing when switched to so that players know what just happened
sheepluva
parents:
4403
diff
changeset
|
383 |
AddCaption(s, Team^.Clan^.Color, capgrpAmmoinfo); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
384 |
if (Propz and ammoprop_NeedTarget) <> 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
385 |
begin |
7341
d70478d265ec
Fix crash when hedgehog dies while switching from it
unc0rr
parents:
7337
diff
changeset
|
386 |
if Gear <> nil then Gear^.State:= Gear^.State or gstHHChooseTarget; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
387 |
isCursorVisible:= true |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
388 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
389 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
390 |
begin |
7426
55b49cc1f33a
Changes for the benefit of pas2c. Use downto in for loops to avoid repeated calls of Random/GetRandom. Wrap nots.
nemo
parents:
7341
diff
changeset
|
391 |
if Gear <> nil then Gear^.State:= Gear^.State and (not gstHHChooseTarget); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
392 |
isCursorVisible:= false |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
393 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
394 |
end |
3935 | 395 |
end; |
553
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
396 |
end; |
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
397 |
|
1922 | 398 |
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
|
399 |
begin |
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
400 |
with Hedgehog do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
401 |
if ((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_DontHold) <> 0) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
402 |
or (Ammoz[CurAmmoType].SkipTurns - CurrentTeam^.Clan^.TurnNumber >= 0) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
403 |
SwitchToFirstLegalAmmo(Hedgehog); |
553
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
404 |
end; |
5478386d935f
- Switch to bazooka (or whatever) after use of some weapon (fixes problem with bots)
unc0rr
parents:
547
diff
changeset
|
405 |
|
783 | 406 |
procedure SetWeapon(weap: TAmmoType); |
407 |
begin |
|
1850 | 408 |
ParseCommand('/setweap ' + char(weap), true) |
783 | 409 |
end; |
410 |
||
1784 | 411 |
procedure DisableSomeWeapons; |
412 |
var i, slot, a: Longword; |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
413 |
t: TAmmoType; |
1784 | 414 |
begin |
415 |
for i:= 0 to Pred(StoreCnt) do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
416 |
for slot:= 0 to cMaxSlotIndex do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
417 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
418 |
for a:= 0 to cMaxSlotAmmoIndex do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
419 |
with StoresList[i]^[slot, a] do |
3697 | 420 |
if (Propz and ammoprop_NotBorder) <> 0 then |
3319 | 421 |
begin |
422 |
Count:= 0; |
|
3951
c9a63db3e603
Correct another bug in slot switching, adjust width of theme list, really truly fix reset of weps (I hope) should also fix infinite teleport bug in place hogs mode. Slow update of health to 5s for inf attack mode.
nemo
parents:
3943
diff
changeset
|
423 |
InitialCounts[i][AmmoType]:= 0 |
3319 | 424 |
end; |
1784 | 425 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
426 |
PackAmmo(StoresList[i], slot) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
427 |
end; |
1784 | 428 |
|
429 |
for t:= Low(TAmmoType) to High(TAmmoType) do |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
430 |
if (Ammoz[t].Ammo.Propz and ammoprop_NotBorder) <> 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
431 |
Ammoz[t].Probability:= 0 |
1784 | 432 |
end; |
433 |
||
6898 | 434 |
procedure SetAmmoLoadout(var s: shortstring); |
3346 | 435 |
begin |
436 |
ammoLoadout:= s; |
|
437 |
end; |
|
438 |
||
6898 | 439 |
procedure SetAmmoProbability(var s: shortstring); |
3346 | 440 |
begin |
441 |
ammoProbability:= s; |
|
442 |
end; |
|
443 |
||
6898 | 444 |
procedure SetAmmoDelay(var s: shortstring); |
3346 | 445 |
begin |
446 |
ammoDelay:= s; |
|
447 |
end; |
|
448 |
||
6898 | 449 |
procedure SetAmmoReinforcement(var s: shortstring); |
3346 | 450 |
begin |
451 |
ammoReinforcement:= s; |
|
452 |
end; |
|
453 |
||
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2732
diff
changeset
|
454 |
// 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
|
455 |
procedure ResetWeapons; |
3955 | 456 |
var i, t: Longword; |
457 |
a: TAmmoType; |
|
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2732
diff
changeset
|
458 |
begin |
3955 | 459 |
for t:= 0 to Pred(TeamsCount) do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
460 |
with TeamsArray[t]^ do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
461 |
for i:= 0 to cMaxHHIndex do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
462 |
Hedgehogs[i].CurAmmoType:= amNothing; |
6519 | 463 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
464 |
for i:= 0 to Pred(StoreCnt) do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
465 |
FillAmmoStore(StoresList[i], InitialCounts[i]); |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2732
diff
changeset
|
466 |
|
3955 | 467 |
for a:= Low(TAmmoType) to High(TAmmoType) do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
468 |
if Ammoz[a].SkipTurns >= 10000 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
469 |
dec(Ammoz[a].SkipTurns,10000) |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2732
diff
changeset
|
470 |
end; |
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2732
diff
changeset
|
471 |
|
4401 | 472 |
|
473 |
||
474 |
procedure chAddAmmoStore(var descr: shortstring); |
|
475 |
begin |
|
476 |
descr:= ''; // avoid compiler hint |
|
477 |
AddAmmoStore |
|
478 |
end; |
|
479 |
||
3038 | 480 |
procedure initModule; |
6762
85ba0c55d077
Set default empty ammo sets. Current mission handling appears to not pass any default ammo set, so script was never getting a chance to set its own.
nemo
parents:
6700
diff
changeset
|
481 |
var i: Longword; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2715
diff
changeset
|
482 |
begin |
6898 | 483 |
RegisterVariable('ammloadt', @SetAmmoLoadout, false); |
484 |
RegisterVariable('ammdelay', @SetAmmoDelay, false); |
|
485 |
RegisterVariable('ammprob', @SetAmmoProbability, false); |
|
486 |
RegisterVariable('ammreinf', @SetAmmoReinforcement, false); |
|
487 |
RegisterVariable('ammstore', @chAddAmmoStore , false); |
|
4401 | 488 |
|
3346 | 489 |
StoreCnt:= 0; |
490 |
ammoLoadout:= ''; |
|
491 |
ammoProbability:= ''; |
|
492 |
ammoDelay:= ''; |
|
3951
c9a63db3e603
Correct another bug in slot switching, adjust width of theme list, really truly fix reset of weps (I hope) should also fix infinite teleport bug in place hogs mode. Slow update of health to 5s for inf attack mode.
nemo
parents:
3943
diff
changeset
|
493 |
ammoReinforcement:= ''; |
6762
85ba0c55d077
Set default empty ammo sets. Current mission handling appears to not pass any default ammo set, so script was never getting a chance to set its own.
nemo
parents:
6700
diff
changeset
|
494 |
for i:=1 to ord(High(TAmmoType)) do |
85ba0c55d077
Set default empty ammo sets. Current mission handling appears to not pass any default ammo set, so script was never getting a chance to set its own.
nemo
parents:
6700
diff
changeset
|
495 |
begin |
85ba0c55d077
Set default empty ammo sets. Current mission handling appears to not pass any default ammo set, so script was never getting a chance to set its own.
nemo
parents:
6700
diff
changeset
|
496 |
ammoLoadout:= ammoLoadout + '0'; |
85ba0c55d077
Set default empty ammo sets. Current mission handling appears to not pass any default ammo set, so script was never getting a chance to set its own.
nemo
parents:
6700
diff
changeset
|
497 |
ammoProbability:= ammoProbability + '0'; |
85ba0c55d077
Set default empty ammo sets. Current mission handling appears to not pass any default ammo set, so script was never getting a chance to set its own.
nemo
parents:
6700
diff
changeset
|
498 |
ammoDelay:= ammoDelay + '0'; |
85ba0c55d077
Set default empty ammo sets. Current mission handling appears to not pass any default ammo set, so script was never getting a chance to set its own.
nemo
parents:
6700
diff
changeset
|
499 |
ammoReinforcement:= ammoReinforcement + '0' |
85ba0c55d077
Set default empty ammo sets. Current mission handling appears to not pass any default ammo set, so script was never getting a chance to set its own.
nemo
parents:
6700
diff
changeset
|
500 |
end; |
3951
c9a63db3e603
Correct another bug in slot switching, adjust width of theme list, really truly fix reset of weps (I hope) should also fix infinite teleport bug in place hogs mode. Slow update of health to 5s for inf attack mode.
nemo
parents:
3943
diff
changeset
|
501 |
FillChar(InitialCounts, sizeof(InitialCounts), 0) |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2715
diff
changeset
|
502 |
end; |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2715
diff
changeset
|
503 |
|
3038 | 504 |
procedure freeModule; |
2715
0e4e0db79e2a
Free up some unfreed memory. Needed for Koda's iphone lib work
nemo
parents:
2630
diff
changeset
|
505 |
var i: LongWord; |
0e4e0db79e2a
Free up some unfreed memory. Needed for Koda's iphone lib work
nemo
parents:
2630
diff
changeset
|
506 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2860
diff
changeset
|
507 |
if StoreCnt > 0 then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
508 |
for i:= 0 to Pred(StoreCnt) do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6519
diff
changeset
|
509 |
Dispose(StoresList[i]) |
2715
0e4e0db79e2a
Free up some unfreed memory. Needed for Koda's iphone lib work
nemo
parents:
2630
diff
changeset
|
510 |
end; |
0e4e0db79e2a
Free up some unfreed memory. Needed for Koda's iphone lib work
nemo
parents:
2630
diff
changeset
|
511 |
|
288 | 512 |
end. |