author | koda |
Wed, 12 Jun 2013 11:18:20 +0200 | |
changeset 9209 | 2c1e00a764bd |
parent 9139 | 2ae44c4381cd |
child 9160 | fc46e75f6b72 |
child 9283 | 76e68c136a11 |
permissions | -rw-r--r-- |
6581 | 1 |
(* |
2 |
* Hedgewars, a free turn based strategy game |
|
9080 | 3 |
* Copyright (c) 2004-2013 Andrey Korotaev <unC0Rr@gmail.com> |
6581 | 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 |
||
19 |
{$INCLUDE "options.inc"} |
|
20 |
||
21 |
unit uGearsHedgehog; |
|
22 |
interface |
|
23 |
uses uTypes; |
|
24 |
||
25 |
procedure doStepHedgehog(Gear: PGear); |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
26 |
procedure AfterAttack; |
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
27 |
procedure HedgehogStep(Gear: PGear); |
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
28 |
procedure doStepHedgehogMoving(Gear: PGear); |
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
29 |
procedure HedgehogChAngle(HHGear: PGear); |
6581 | 30 |
procedure PickUp(HH, Gear: PGear); |
7389
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
31 |
procedure AddPickup(HH: THedgehog; ammo: TAmmoType; cnt, X, Y: LongWord); |
8574 | 32 |
procedure CheckIce(Gear: PGear); inline; |
6581 | 33 |
|
34 |
implementation |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
35 |
uses uConsts, uVariables, uFloat, uAmmos, uSound, uCaptions, |
6581 | 36 |
uCommands, uLocale, uUtils, uVisualGears, uStats, uIO, uScript, |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
37 |
uGearsList, uGears, uCollisions, uRandom, uStore, uTeams, |
6581 | 38 |
uGearsUtils; |
39 |
||
7028 | 40 |
var GHStepTicks: LongWord = 0; |
41 |
||
6581 | 42 |
// Shouldn't more of this ammo switching stuff be moved to uAmmos ? |
43 |
function ChangeAmmo(HHGear: PGear): boolean; |
|
44 |
var slot, i: Longword; |
|
45 |
ammoidx: LongInt; |
|
7754 | 46 |
prevAmmo: TAmmoType; |
6581 | 47 |
begin |
48 |
ChangeAmmo:= false; |
|
49 |
slot:= HHGear^.MsgParam; |
|
50 |
||
51 |
with HHGear^.Hedgehog^ do |
|
52 |
begin |
|
53 |
HHGear^.Message:= HHGear^.Message and (not gmSlot); |
|
7754 | 54 |
prevAmmo:= CurAmmoType; |
6581 | 55 |
ammoidx:= 0; |
56 |
if ((HHGear^.State and (gstAttacking or gstAttacked)) <> 0) |
|
57 |
or ((HHGear^.State and gstHHDriven) = 0) then |
|
58 |
exit; |
|
59 |
ChangeAmmo:= true; |
|
60 |
||
61 |
while (ammoidx < cMaxSlotAmmoIndex) and (Ammo^[slot, ammoidx].AmmoType <> CurAmmoType) do |
|
62 |
inc(ammoidx); |
|
63 |
||
8553
a8e1cff496d8
Allow switching away from any weapon when during multishoot.
nemo
parents:
8494
diff
changeset
|
64 |
if (MultiShootAttacks > 0) then |
a8e1cff496d8
Allow switching away from any weapon when during multishoot.
nemo
parents:
8494
diff
changeset
|
65 |
begin |
a8e1cff496d8
Allow switching away from any weapon when during multishoot.
nemo
parents:
8494
diff
changeset
|
66 |
if (CurAmmoType = amSniperRifle) and ((GameFlags and gfArtillery) = 0) then |
a8e1cff496d8
Allow switching away from any weapon when during multishoot.
nemo
parents:
8494
diff
changeset
|
67 |
cArtillery := false; |
8631
796ed875aa95
Call act as if attack ended on last shot if switching while in mid multi-shoot. Thanks to AI for discovering this.
nemo
parents:
8616
diff
changeset
|
68 |
if (Ammoz[CurAmmoType].Ammo.Propz and ammoprop_NoRoundEnd) = 0 then |
796ed875aa95
Call act as if attack ended on last shot if switching while in mid multi-shoot. Thanks to AI for discovering this.
nemo
parents:
8616
diff
changeset
|
69 |
begin |
796ed875aa95
Call act as if attack ended on last shot if switching while in mid multi-shoot. Thanks to AI for discovering this.
nemo
parents:
8616
diff
changeset
|
70 |
MultiShootAttacks:= Ammoz[CurAmmoType].Ammo.NumPerTurn; |
796ed875aa95
Call act as if attack ended on last shot if switching while in mid multi-shoot. Thanks to AI for discovering this.
nemo
parents:
8616
diff
changeset
|
71 |
AfterAttack |
796ed875aa95
Call act as if attack ended on last shot if switching while in mid multi-shoot. Thanks to AI for discovering this.
nemo
parents:
8616
diff
changeset
|
72 |
end |
796ed875aa95
Call act as if attack ended on last shot if switching while in mid multi-shoot. Thanks to AI for discovering this.
nemo
parents:
8616
diff
changeset
|
73 |
else OnUsedAmmo(HHGear^.Hedgehog^) |
8553
a8e1cff496d8
Allow switching away from any weapon when during multishoot.
nemo
parents:
8494
diff
changeset
|
74 |
end; |
6581 | 75 |
|
76 |
MultiShootAttacks:= 0; |
|
77 |
HHGear^.Message:= HHGear^.Message and (not (gmLJump or gmHJump)); |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
78 |
|
6581 | 79 |
if Ammoz[CurAmmoType].Slot = slot then |
80 |
begin |
|
81 |
i:= 0; |
|
82 |
repeat |
|
83 |
inc(ammoidx); |
|
84 |
if (ammoidx > cMaxSlotAmmoIndex) then |
|
85 |
begin |
|
86 |
inc(i); |
|
87 |
CurAmmoType:= amNothing; |
|
88 |
ammoidx:= -1; |
|
89 |
//TryDo(i < 2, 'Engine bug: no ammo in current slot', true) |
|
90 |
end; |
|
91 |
until (i = 1) or ((Ammo^[slot, ammoidx].Count > 0) |
|
92 |
and (Team^.Clan^.TurnNumber > Ammoz[Ammo^[slot, ammoidx].AmmoType].SkipTurns)) |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
93 |
|
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
94 |
end |
6581 | 95 |
else |
96 |
begin |
|
97 |
i:= 0; |
|
98 |
// check whether there is ammo in slot |
|
99 |
while (i <= cMaxSlotAmmoIndex) and ((Ammo^[slot, i].Count = 0) |
|
100 |
or (Team^.Clan^.TurnNumber <= Ammoz[Ammo^[slot, i].AmmoType].SkipTurns)) |
|
101 |
do inc(i); |
|
102 |
||
103 |
if i <= cMaxSlotAmmoIndex then |
|
104 |
ammoidx:= i |
|
105 |
else ammoidx:= -1 |
|
106 |
end; |
|
107 |
if ammoidx >= 0 then |
|
108 |
CurAmmoType:= Ammo^[slot, ammoidx].AmmoType; |
|
7754 | 109 |
if (prevAmmo <> CurAmmoType) then |
110 |
begin |
|
111 |
if CurAmmoType = amKnife then |
|
112 |
LoadHedgehogHat(HHGear^.Hedgehog^, 'Reserved/chef') |
|
113 |
else if prevAmmo = amKnife then |
|
114 |
LoadHedgehogHat(HHGear^.Hedgehog^, Hat); |
|
8051
f26422ef0333
oft-requested, should make the shoppa guys happy, probably, but, knowing them, I'm sure someone will complain
nemo
parents:
8030
diff
changeset
|
115 |
end; |
f26422ef0333
oft-requested, should make the shoppa guys happy, probably, but, knowing them, I'm sure someone will complain
nemo
parents:
8030
diff
changeset
|
116 |
// Try again in the next slot |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
117 |
if CurAmmoType = prevAmmo then |
8051
f26422ef0333
oft-requested, should make the shoppa guys happy, probably, but, knowing them, I'm sure someone will complain
nemo
parents:
8030
diff
changeset
|
118 |
begin |
f26422ef0333
oft-requested, should make the shoppa guys happy, probably, but, knowing them, I'm sure someone will complain
nemo
parents:
8030
diff
changeset
|
119 |
if slot >= cMaxSlotIndex then slot:= 0 else inc(slot); |
f26422ef0333
oft-requested, should make the shoppa guys happy, probably, but, knowing them, I'm sure someone will complain
nemo
parents:
8030
diff
changeset
|
120 |
HHGear^.MsgParam:= slot; |
f26422ef0333
oft-requested, should make the shoppa guys happy, probably, but, knowing them, I'm sure someone will complain
nemo
parents:
8030
diff
changeset
|
121 |
ChangeAmmo(HHGear) |
7754 | 122 |
end |
6581 | 123 |
end |
124 |
end; |
|
125 |
||
126 |
procedure HHSetWeapon(HHGear: PGear); |
|
127 |
var t: LongInt; |
|
128 |
weap: TAmmoType; |
|
129 |
Hedgehog: PHedgehog; |
|
130 |
s: boolean; |
|
131 |
begin |
|
132 |
s:= false; |
|
133 |
||
134 |
weap:= TAmmoType(HHGear^.MsgParam); |
|
135 |
Hedgehog:= HHGear^.Hedgehog; |
|
136 |
||
137 |
if Hedgehog^.Team^.Clan^.TurnNumber <= Ammoz[weap].SkipTurns then |
|
138 |
exit; // weapon is not activated yet |
|
139 |
||
140 |
HHGear^.MsgParam:= Ammoz[weap].Slot; |
|
141 |
||
142 |
t:= cMaxSlotAmmoIndex; |
|
143 |
||
144 |
HHGear^.Message:= HHGear^.Message and (not gmWeapon); |
|
145 |
||
146 |
with Hedgehog^ do |
|
147 |
while (CurAmmoType <> weap) and (t >= 0) do |
|
148 |
begin |
|
149 |
s:= ChangeAmmo(HHGear); |
|
150 |
dec(t) |
|
151 |
end; |
|
152 |
||
153 |
if s then |
|
154 |
ApplyAmmoChanges(HHGear^.Hedgehog^) |
|
155 |
end; |
|
156 |
||
157 |
procedure HHSetTimer(Gear: PGear); |
|
158 |
var CurWeapon: PAmmo; |
|
159 |
color: LongWord; |
|
160 |
begin |
|
161 |
Gear^.Message:= Gear^.Message and (not gmTimer); |
|
6924 | 162 |
CurWeapon:= GetCurAmmoEntry(Gear^.Hedgehog^); |
6581 | 163 |
with Gear^.Hedgehog^ do |
164 |
if ((Gear^.Message and gmPrecise) <> 0) and ((CurWeapon^.Propz and ammoprop_SetBounce) <> 0) then |
|
165 |
begin |
|
166 |
color:= Gear^.Hedgehog^.Team^.Clan^.Color; |
|
167 |
case Gear^.MsgParam of |
|
168 |
1: begin |
|
7069 | 169 |
AddCaption(FormatA(trmsg[sidBounce], trmsg[sidBounce1]), color, capgrpAmmostate); |
6581 | 170 |
CurWeapon^.Bounciness:= 350; |
171 |
end; |
|
172 |
2: begin |
|
7069 | 173 |
AddCaption(FormatA(trmsg[sidBounce], trmsg[sidBounce2]), color, capgrpAmmostate); |
6581 | 174 |
CurWeapon^.Bounciness:= 700; |
175 |
end; |
|
176 |
3: begin |
|
7069 | 177 |
AddCaption(FormatA(trmsg[sidBounce], trmsg[sidBounce3]), color, capgrpAmmostate); |
6581 | 178 |
CurWeapon^.Bounciness:= 1000; |
179 |
end; |
|
180 |
4: begin |
|
7069 | 181 |
AddCaption(FormatA(trmsg[sidBounce], trmsg[sidBounce4]), color, capgrpAmmostate); |
6581 | 182 |
CurWeapon^.Bounciness:= 2000; |
183 |
end; |
|
184 |
5: begin |
|
7069 | 185 |
AddCaption(FormatA(trmsg[sidBounce], trmsg[sidBounce5]), color, capgrpAmmostate); |
6581 | 186 |
CurWeapon^.Bounciness:= 4000; |
187 |
end |
|
188 |
end |
|
189 |
end |
|
190 |
else if (CurWeapon^.Propz and ammoprop_Timerable) <> 0 then |
|
191 |
begin |
|
192 |
CurWeapon^.Timer:= 1000 * Gear^.MsgParam; |
|
193 |
with CurrentTeam^ do |
|
194 |
ApplyAmmoChanges(Hedgehogs[CurrHedgehog]); |
|
195 |
end; |
|
196 |
end; |
|
197 |
||
198 |
||
199 |
procedure Attack(Gear: PGear); |
|
200 |
var xx, yy, newDx, newDy, lx, ly: hwFloat; |
|
201 |
speech: PVisualGear; |
|
202 |
newGear: PGear; |
|
203 |
CurWeapon: PAmmo; |
|
204 |
altUse: boolean; |
|
205 |
elastic: hwFloat; |
|
206 |
begin |
|
207 |
newGear:= nil; |
|
208 |
bShowFinger:= false; |
|
6924 | 209 |
CurWeapon:= GetCurAmmoEntry(Gear^.Hedgehog^); |
6581 | 210 |
with Gear^, |
211 |
Gear^.Hedgehog^ do |
|
212 |
begin |
|
213 |
if ((State and gstHHDriven) <> 0) and ((State and (gstAttacked or gstHHChooseTarget)) = 0) and (((State and gstMoving) = 0) |
|
214 |
or (Power > 0) |
|
215 |
or (CurAmmoType = amTeleport) |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
216 |
or |
6581 | 217 |
// Allow attacks while moving on ammo with AltAttack |
218 |
((CurAmmoGear <> nil) and ((Ammoz[CurAmmoGear^.AmmoType].Ammo.Propz and ammoprop_AltAttack) <> 0)) |
|
219 |
or ((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_AttackInMove) <> 0)) |
|
220 |
and ((TargetPoint.X <> NoPointX) or ((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_NeedTarget) = 0)) then |
|
221 |
begin |
|
222 |
State:= State or gstAttacking; |
|
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
223 |
if (Power = cMaxPower) or ((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_Power) = 0) then |
6581 | 224 |
Message:= Message and (not gmAttack) |
225 |
else |
|
226 |
begin |
|
227 |
if Power = 0 then |
|
228 |
begin |
|
229 |
AttackBar:= CurrentTeam^.AttackBar; |
|
230 |
PlaySound(sndThrowPowerUp) |
|
231 |
end; |
|
232 |
inc(Power) |
|
233 |
end; |
|
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
234 |
if ((Message and gmAttack) <> 0) then |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
235 |
exit; |
6581 | 236 |
|
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
237 |
if (Ammoz[CurAmmoType].Ammo.Propz and ammoprop_Power) <> 0 then |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
238 |
begin |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
239 |
StopSound(sndThrowPowerUp); |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
240 |
PlaySound(sndThrowRelease); |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
241 |
end; |
6581 | 242 |
|
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
243 |
xx:= SignAs(AngleSin(Angle), dX); |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
244 |
yy:= -AngleCos(Angle); |
6581 | 245 |
|
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
246 |
lx:= X + int2hwfloat(round(GetLaunchX(CurAmmoType, hwSign(dX), Angle))); |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
247 |
ly:= Y + int2hwfloat(round(GetLaunchY(CurAmmoType, Angle))); |
6581 | 248 |
|
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
249 |
if ((Gear^.State and gstHHHJump) <> 0) and (not cArtillery) then |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
250 |
xx:= - xx; |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
251 |
if Ammoz[CurAmmoType].Ammo.AttackVoice <> sndNone then |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
252 |
AddVoice(Ammoz[CurAmmoType].Ammo.AttackVoice, CurrentTeam^.voicepack); |
6581 | 253 |
|
254 |
// Initiating alt attack |
|
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
255 |
if (CurAmmoGear <> nil) |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
256 |
and ((Ammoz[CurAmmoGear^.AmmoType].Ammo.Propz and ammoprop_AltAttack) <> 0) |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
257 |
and ((Gear^.Message and gmLJump) <> 0) |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
258 |
and ((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_AltUse) <> 0) then |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
259 |
begin |
8987
47cf32305d99
some saucer thing for firing weps underwater and aiming and such. bit drunk and sleepy so testing I guess
nemo
parents:
8947
diff
changeset
|
260 |
if (CurAmmoGear^.AmmoType = amJetpack) and (Gear^.Message and gmPrecise <> 0) then |
47cf32305d99
some saucer thing for firing weps underwater and aiming and such. bit drunk and sleepy so testing I guess
nemo
parents:
8947
diff
changeset
|
261 |
begin |
8992
5b0be812dcdb
Rename submersible state, increase getaway time for attack underwater, slow down gear dx/dy underwater to simulate water resistance
nemo
parents:
8987
diff
changeset
|
262 |
newDx:= xx*cMaxPower/cPowerDivisor; |
5b0be812dcdb
Rename submersible state, increase getaway time for attack underwater, slow down gear dx/dy underwater to simulate water resistance
nemo
parents:
8987
diff
changeset
|
263 |
newDy:= yy*cMaxPower/cPowerDivisor |
8987
47cf32305d99
some saucer thing for firing weps underwater and aiming and such. bit drunk and sleepy so testing I guess
nemo
parents:
8947
diff
changeset
|
264 |
end |
47cf32305d99
some saucer thing for firing weps underwater and aiming and such. bit drunk and sleepy so testing I guess
nemo
parents:
8947
diff
changeset
|
265 |
else |
47cf32305d99
some saucer thing for firing weps underwater and aiming and such. bit drunk and sleepy so testing I guess
nemo
parents:
8947
diff
changeset
|
266 |
begin |
47cf32305d99
some saucer thing for firing weps underwater and aiming and such. bit drunk and sleepy so testing I guess
nemo
parents:
8947
diff
changeset
|
267 |
newDx:= dX; |
47cf32305d99
some saucer thing for firing weps underwater and aiming and such. bit drunk and sleepy so testing I guess
nemo
parents:
8947
diff
changeset
|
268 |
newDy:= dY |
47cf32305d99
some saucer thing for firing weps underwater and aiming and such. bit drunk and sleepy so testing I guess
nemo
parents:
8947
diff
changeset
|
269 |
end; |
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
270 |
altUse:= true |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
271 |
end |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
272 |
else |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
273 |
begin |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
274 |
newDx:= xx*Power/cPowerDivisor; |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
275 |
newDy:= yy*Power/cPowerDivisor; |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
276 |
altUse:= false |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
277 |
end; |
6581 | 278 |
|
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
279 |
case CurAmmoType of |
6581 | 280 |
amGrenade: newGear:= AddGear(hwRound(lx), hwRound(ly), gtGrenade, 0, newDx, newDy, CurWeapon^.Timer); |
281 |
amMolotov: newGear:= AddGear(hwRound(lx), hwRound(ly), gtMolotov, 0, newDx, newDy, 0); |
|
282 |
amClusterBomb: newGear:= AddGear(hwRound(lx), hwRound(ly), gtClusterBomb, 0, newDx, newDy, CurWeapon^.Timer); |
|
283 |
amGasBomb: newGear:= AddGear(hwRound(lx), hwRound(ly), gtGasBomb, 0, newDx, newDy, CurWeapon^.Timer); |
|
284 |
amBazooka: newGear:= AddGear(hwRound(lx), hwRound(ly), gtShell, 0, newDx, newDy, 0); |
|
285 |
amSnowball: newGear:= AddGear(hwRound(lx), hwRound(ly), gtSnowball, 0, newDx, newDy, 0); |
|
286 |
amBee: newGear:= AddGear(hwRound(lx), hwRound(ly), gtBee, 0, newDx, newDy, 0); |
|
287 |
amShotgun: begin |
|
288 |
PlaySound(sndShotgunReload); |
|
289 |
newGear:= AddGear(hwRound(lx), hwRound(ly), gtShotgunShot, 0, xx * _0_5, yy * _0_5, 0); |
|
290 |
end; |
|
291 |
amPickHammer: newGear:= AddGear(hwRound(lx), hwRound(ly) + cHHRadius, gtPickHammer, 0, _0, _0, 0); |
|
292 |
amSkip: ParseCommand('/skip', true); |
|
293 |
amRope: newGear:= AddGear(hwRound(lx), hwRound(ly), gtRope, 0, xx, yy, 0); |
|
7602
a620319d377e
Fix throwing things off rope, also make throwing things a bit more generic and gear density dependent (so you can throw mines further, and also throw dynamite a little).
nemo
parents:
7598
diff
changeset
|
294 |
amMine: newGear:= AddGear(hwRound(lx) + hwSign(dX) * 7, hwRound(ly), gtMine, gstWait, SignAs(_0_02, dX), _0, 3000); |
6581 | 295 |
amSMine: newGear:= AddGear(hwRound(lx), hwRound(ly), gtSMine, 0, xx*Power/cPowerDivisor, yy*Power/cPowerDivisor, 0); |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
296 |
amKnife: begin |
7754 | 297 |
newGear:= AddGear(hwRound(lx), hwRound(ly), gtKnife, 0, xx*Power/cPowerDivisor, yy*Power/cPowerDivisor, 0); |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
298 |
newGear^.State:= newGear^.State or gstMoving; |
8494
53b91a602955
Cleaver tweaks based on feedback. Nerf damage, shrink radius. This means cleaver will embed into ground quite a bit further.
nemo
parents:
8493
diff
changeset
|
299 |
newGear^.Radius:= 4 // temporarily shrink so it doesn't instantly embed in the ground |
7754 | 300 |
end; |
6581 | 301 |
amDEagle: newGear:= AddGear(hwRound(lx + xx * cHHRadius), hwRound(ly + yy * cHHRadius), gtDEagleShot, 0, xx * _0_5, yy * _0_5, 0); |
302 |
amSineGun: newGear:= AddGear(hwRound(lx + xx * cHHRadius), hwRound(ly + yy * cHHRadius), gtSineGunShot, 0, xx * _0_5, yy * _0_5, 0); |
|
303 |
amPortalGun: begin |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
304 |
newGear:= AddGear(hwRound(lx + xx * cHHRadius), hwRound(ly + yy * cHHRadius), gtPortal, 0, xx * _0_6, yy * _0_6, |
6581 | 305 |
// set selected color |
306 |
CurWeapon^.Pos); |
|
307 |
end; |
|
308 |
amSniperRifle: begin |
|
309 |
PlaySound(sndSniperReload); |
|
310 |
newGear:= AddGear(hwRound(lx + xx * cHHRadius), hwRound(ly + yy * cHHRadius), gtSniperRifleShot, 0, xx * _0_5, yy * _0_5, 0); |
|
311 |
end; |
|
312 |
amDynamite: newGear:= AddGear(hwRound(lx) + hwSign(dX) * 7, hwRound(ly), gtDynamite, 0, SignAs(_0_03, dX), _0, 5000); |
|
313 |
amFirePunch: newGear:= AddGear(hwRound(lx) + hwSign(dX) * 10, hwRound(ly), gtFirePunch, 0, xx, _0, 0); |
|
314 |
amWhip: begin |
|
315 |
newGear:= AddGear(hwRound(lx) + hwSign(dX) * 10, hwRound(ly), gtWhip, 0, SignAs(_1, dX), - _0_8, 0); |
|
316 |
PlaySound(sndWhipCrack) |
|
317 |
end; |
|
318 |
amHammer: begin |
|
319 |
newGear:= AddGear(hwRound(lx) + hwSign(dX) * 10, hwRound(ly), gtHammer, 0, SignAs(_1, dX), - _0_8, 0); |
|
320 |
PlaySound(sndWhack) |
|
321 |
end; |
|
322 |
amBaseballBat: begin |
|
323 |
newGear:= AddGear(hwRound(lx) + hwSign(dX) * 10, hwRound(ly), gtShover, gsttmpFlag, xx * _0_5, yy * _0_5, 0); |
|
324 |
PlaySound(sndBaseballBat) // TODO: Only play if something is hit? |
|
325 |
end; |
|
326 |
amParachute: begin |
|
327 |
newGear:= AddGear(hwRound(lx), hwRound(ly), gtParachute, 0, _0, _0, 0); |
|
328 |
PlaySound(sndParachute) |
|
329 |
end; |
|
330 |
// we save CurWeapon^.Pos (in this case: cursor direction) by using it as (otherwise irrelevant) X value of the new gear. |
|
331 |
amAirAttack: newGear:= AddGear(CurWeapon^.Pos, 0, gtAirAttack, 0, _0, _0, 0); |
|
332 |
amMineStrike: newGear:= AddGear(CurWeapon^.Pos, 0, gtAirAttack, 1, _0, _0, 0); |
|
333 |
amDrillStrike: newGear:= AddGear(CurWeapon^.Pos, 0, gtAirAttack, 3, _0, _0, CurWeapon^.Timer); |
|
334 |
amNapalm: newGear:= AddGear(CurWeapon^.Pos, 0, gtAirAttack, 2, _0, _0, 0); |
|
335 |
amBlowTorch: newGear:= AddGear(hwRound(lx), hwRound(ly), gtBlowTorch, 0, SignAs(_0_5, dX), _0, 0); |
|
336 |
amGirder: newGear:= AddGear(0, 0, gtGirder, CurWeapon^.Pos, _0, _0, 0); |
|
337 |
amTeleport: newGear:= AddGear(CurWeapon^.Pos, 0, gtTeleport, 0, _0, _0, 0); |
|
338 |
amSwitch: newGear:= AddGear(hwRound(lx), hwRound(ly), gtSwitcher, 0, _0, _0, 0); |
|
339 |
amMortar: begin |
|
340 |
playSound(sndMortar); |
|
341 |
newGear:= AddGear(hwRound(lx), hwRound(ly), gtMortar, 0, xx*cMaxPower/cPowerDivisor, yy*cMaxPower/cPowerDivisor, 0); |
|
342 |
end; |
|
343 |
amRCPlane: begin |
|
344 |
newGear:= AddGear(hwRound(lx), hwRound(ly), gtRCPlane, 0, xx * cMaxPower / cPowerDivisor / 4, yy * cMaxPower / cPowerDivisor / 4, 0); |
|
7053 | 345 |
newGear^.SoundChannel:= LoopSound(sndRCPlane) |
6581 | 346 |
end; |
347 |
amKamikaze: newGear:= AddGear(hwRound(lx), hwRound(ly), gtKamikaze, 0, xx * _0_5, yy * _0_5, 0); |
|
7832 | 348 |
amCake: newGear:= AddGear(hwRound(lx) + hwSign(dX) * 3, hwRound(ly), gtCake, 0, SignAs(cLittle, xx), _0, 0); |
6581 | 349 |
amSeduction: newGear:= AddGear(hwRound(lx), hwRound(ly), gtSeduction, 0, _0, _0, 0); |
350 |
amWatermelon: newGear:= AddGear(hwRound(lx), hwRound(ly), gtWatermelon, 0, newDx, newDy, CurWeapon^.Timer); |
|
351 |
amHellishBomb: newGear:= AddGear(hwRound(lx), hwRound(ly), gtHellishBomb, 0, newDx, newDy, 0); |
|
352 |
amDrill: newGear:= AddGear(hwRound(lx), hwRound(ly), gtDrill, 0, newDx, newDy, 0); |
|
353 |
amBallgun: newGear:= AddGear(hwRound(X), hwRound(Y), gtBallgun, 0, xx * _0_5, yy * _0_5, 0); |
|
354 |
amJetpack: newGear:= AddGear(hwRound(lx), hwRound(ly), gtJetpack, 0, _0, _0, 0); |
|
355 |
amBirdy: begin |
|
356 |
PlaySound(sndWhistle); |
|
357 |
newGear:= AddGear(hwRound(lx), hwRound(ly) - 32, gtBirdy, 0, _0, _0, 0); |
|
358 |
end; |
|
359 |
amLowGravity: begin |
|
360 |
PlaySound(sndLowGravity); |
|
361 |
cGravity:= cMaxWindSpeed; |
|
362 |
cGravityf:= 0.00025 |
|
363 |
end; |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
364 |
amExtraDamage: begin |
6581 | 365 |
PlaySound(sndHellishImpact4); |
366 |
cDamageModifier:= _1_5 |
|
367 |
end; |
|
368 |
amInvulnerable: Invulnerable:= true; |
|
369 |
amExtraTime: begin |
|
370 |
PlaySound(sndSwitchHog); |
|
371 |
TurnTimeLeft:= TurnTimeLeft + 30000 |
|
372 |
end; |
|
373 |
amLaserSight: cLaserSighting:= true; |
|
374 |
amVampiric: begin |
|
7053 | 375 |
PlaySoundV(sndOw1, Team^.voicepack); |
6581 | 376 |
cVampiric:= true; |
377 |
end; |
|
378 |
amPiano: begin |
|
379 |
// Tuck the hedgehog away until the piano attack is completed |
|
380 |
Unplaced:= true; |
|
381 |
X:= _0; |
|
382 |
Y:= _0; |
|
8414
c1ac0b64315e
Start piano higher (piano on maps that matched land_height was really weird before). Experiment w/ trying to make birdy shrink into distance to avoid odd birdy vanishes if tracking it.
nemo
parents:
8161
diff
changeset
|
383 |
newGear:= AddGear(TargetPoint.X, -1024, gtPiano, 0, _0, _0, 0); |
6581 | 384 |
PauseMusic |
385 |
end; |
|
386 |
amFlamethrower: newGear:= AddGear(hwRound(X), hwRound(Y), gtFlamethrower, 0, xx * _0_5, yy * _0_5, 0); |
|
387 |
amLandGun: newGear:= AddGear(hwRound(X), hwRound(Y), gtLandGun, 0, xx * _0_5, yy * _0_5, 0); |
|
388 |
amResurrector: begin |
|
389 |
newGear:= AddGear(hwRound(lx), hwRound(ly), gtResurrector, 0, _0, _0, 0); |
|
390 |
newGear^.SoundChannel := LoopSound(sndResurrector); |
|
391 |
end; |
|
8161 | 392 |
//amStructure: newGear:= AddGear(hwRound(lx) + hwSign(dX) * 7, hwRound(ly), gtStructure, gstWait, SignAs(_0_02, dX), _0, 3000); |
6581 | 393 |
amTardis: newGear:= AddGear(hwRound(X), hwRound(Y), gtTardis, 0, _0, _0, 5000); |
8774
39754516eee6
Try to document TGear a bit, so people know what is commonly overridden, and what stuff is used for. Remove gtIceGun-specific values from TGear and abuse a couple of commonly abused members instead.
nemo
parents:
8753
diff
changeset
|
394 |
amIceGun: newGear:= AddGear(hwRound(X), hwRound(Y), gtIceGun, 0, _0, _0, 0); |
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
395 |
end; |
8987
47cf32305d99
some saucer thing for firing weps underwater and aiming and such. bit drunk and sleepy so testing I guess
nemo
parents:
8947
diff
changeset
|
396 |
if altUse and (newGear <> nil) and |
47cf32305d99
some saucer thing for firing weps underwater and aiming and such. bit drunk and sleepy so testing I guess
nemo
parents:
8947
diff
changeset
|
397 |
((CurAmmoGear = nil) or (CurAmmoGear^.AmmoType <> amJetpack) or (Gear^.Message and gmPrecise = 0)) then |
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
398 |
begin |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
399 |
newGear^.dX:= newDx / newGear^.Density; |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
400 |
newGear^.dY:= newDY / newGear^.Density |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
401 |
end; |
8987
47cf32305d99
some saucer thing for firing weps underwater and aiming and such. bit drunk and sleepy so testing I guess
nemo
parents:
8947
diff
changeset
|
402 |
if (CurAmmoGear <> nil) and (CurAmmoGear^.AmmoType = amJetpack) and |
47cf32305d99
some saucer thing for firing weps underwater and aiming and such. bit drunk and sleepy so testing I guess
nemo
parents:
8947
diff
changeset
|
403 |
(Gear^.Message and gmPrecise <> 0) and (hwRound(Y) > cWaterLine) then |
8992
5b0be812dcdb
Rename submersible state, increase getaway time for attack underwater, slow down gear dx/dy underwater to simulate water resistance
nemo
parents:
8987
diff
changeset
|
404 |
newGear^.State:= newGear^.State or gstSubmersible; |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
405 |
|
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
406 |
case CurAmmoType of |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
407 |
amGrenade, amMolotov, |
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
408 |
amClusterBomb, amGasBomb, |
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
409 |
amBazooka, amSnowball, |
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
410 |
amBee, amSMine, |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
411 |
amMortar, amWatermelon, |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
412 |
amHellishBomb, amDrill: FollowGear:= newGear; |
6581 | 413 |
|
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
414 |
amShotgun, amPickHammer, |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
415 |
amRope, amDEagle, |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
416 |
amSineGun, amSniperRifle, |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
417 |
amFirePunch, amWhip, |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
418 |
amHammer, amBaseballBat, |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
419 |
amParachute, amBlowTorch, |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
420 |
amGirder, amTeleport, |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
421 |
amSwitch, amRCPlane, |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
422 |
amKamikaze, amCake, |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
423 |
amSeduction, amBallgun, |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
424 |
amJetpack, amBirdy, |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
425 |
amFlamethrower, amLandGun, |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
426 |
amResurrector, //amStructure, |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
427 |
amTardis, amPiano, |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
428 |
amIceGun: CurAmmoGear:= newGear; |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
429 |
end; |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
430 |
|
6581 | 431 |
if ((CurAmmoType = amMine) or (CurAmmoType = amSMine)) and (GameFlags and gfInfAttack <> 0) then |
432 |
newGear^.FlightTime:= GameTicks + 1000 |
|
433 |
else if CurAmmoType = amDrill then |
|
434 |
newGear^.FlightTime:= GameTicks + 250; |
|
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
435 |
if Ammoz[CurAmmoType].Ammo.Propz and ammoprop_NeedTarget <> 0 then |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
436 |
begin |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
437 |
newGear^.Target.X:= TargetPoint.X; |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
438 |
newGear^.Target.Y:= TargetPoint.Y |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
439 |
end; |
8744 | 440 |
if (newGear <> nil) and (newGear^.CollisionMask and lfCurrentHog <> 0) then newGear^.CollisionMask:= newGear^.CollisionMask and (not lfCurrentHog); |
6581 | 441 |
|
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
442 |
// Clear FollowGear if using on a rope/parachute/saucer etc so focus stays with the hog's movement |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
443 |
if altUse then |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
444 |
FollowGear:= nil; |
6581 | 445 |
|
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
446 |
if (newGear <> nil) and ((Ammoz[newGear^.AmmoType].Ammo.Propz and ammoprop_SetBounce) <> 0) then |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
447 |
begin |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
448 |
elastic:= int2hwfloat(CurWeapon^.Bounciness) / _1000; |
6581 | 449 |
|
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
450 |
if elastic < _1 then |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
451 |
newGear^.Elasticity:= newGear^.Elasticity * elastic |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
452 |
else if elastic > _1 then |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
453 |
newGear^.Elasticity:= _1 - ((_1-newGear^.Elasticity) / elastic); |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
454 |
(* Experimented with friction modifier. Didn't seem helpful |
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
455 |
fric:= int2hwfloat(CurWeapon^.Bounciness) / _250; |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
456 |
if fric < _1 then newGear^.Friction:= newGear^.Friction * fric |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
457 |
else if fric > _1 then newGear^.Friction:= _1 - ((_1-newGear^.Friction) / fric)*) |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
458 |
end; |
6581 | 459 |
|
460 |
||
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
461 |
uStats.AmmoUsed(CurAmmoType); |
6581 | 462 |
|
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
463 |
if not (SpeechText = '') then |
6581 | 464 |
begin |
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
465 |
speech:= AddVisualGear(0, 0, vgtSpeechBubble); |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
466 |
if speech <> nil then |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
467 |
begin |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
468 |
speech^.Text:= SpeechText; |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
469 |
speech^.Hedgehog:= Gear^.Hedgehog; |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
470 |
speech^.FrameTicks:= SpeechType; |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
471 |
end; |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
472 |
SpeechText:= '' |
6581 | 473 |
end; |
474 |
||
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
475 |
Power:= 0; |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
476 |
if (CurAmmoGear <> nil) |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
477 |
and ((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_AltUse) = 0){check for dropping ammo from rope} then |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
478 |
begin |
8566
d9627d65edf7
This and the "retain freezing" stuff could probably use a flag.
nemo
parents:
8562
diff
changeset
|
479 |
if CurAmmoType in [amRope,amResurrector] then Message:= Message or gmAttack; |
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
480 |
CurAmmoGear^.Message:= Message |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
481 |
end |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
482 |
else |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
483 |
begin |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
484 |
if not CurrentTeam^.ExtDriven |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
485 |
and ((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_Power) <> 0) then |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
486 |
SendIPC(_S'a'); |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
487 |
AfterAttack; |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
488 |
end |
6581 | 489 |
end |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
490 |
else |
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
491 |
Message:= Message and (not gmAttack); |
6581 | 492 |
end; |
493 |
TargetPoint.X := NoPointX; |
|
494 |
ScriptCall('onHogAttack'); |
|
495 |
end; |
|
496 |
||
497 |
procedure AfterAttack; |
|
498 |
var s: shortstring; |
|
499 |
a: TAmmoType; |
|
7459
8511a3f899d3
Allow AfterAttack to proceed even if the Hedgehog is dead. They could be resurrected after all.
nemo
parents:
7426
diff
changeset
|
500 |
HHGear: PGear; |
6581 | 501 |
begin |
7459
8511a3f899d3
Allow AfterAttack to proceed even if the Hedgehog is dead. They could be resurrected after all.
nemo
parents:
7426
diff
changeset
|
502 |
with CurrentHedgehog^ do |
6581 | 503 |
begin |
7459
8511a3f899d3
Allow AfterAttack to proceed even if the Hedgehog is dead. They could be resurrected after all.
nemo
parents:
7426
diff
changeset
|
504 |
HHGear:= Gear; |
6581 | 505 |
a:= CurAmmoType; |
7459
8511a3f899d3
Allow AfterAttack to proceed even if the Hedgehog is dead. They could be resurrected after all.
nemo
parents:
7426
diff
changeset
|
506 |
if HHGear <> nil then HHGear^.State:= HHGear^.State and (not gstAttacking); |
6581 | 507 |
if (Ammoz[a].Ammo.Propz and ammoprop_Effect) = 0 then |
508 |
begin |
|
509 |
Inc(MultiShootAttacks); |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
510 |
|
6581 | 511 |
if (Ammoz[a].Ammo.NumPerTurn >= MultiShootAttacks) then |
512 |
begin |
|
513 |
s:= inttostr(Ammoz[a].Ammo.NumPerTurn - MultiShootAttacks + 1); |
|
514 |
AddCaption(format(trmsg[sidRemaining], s), cWhiteColor, capgrpAmmostate); |
|
515 |
end; |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
516 |
|
6581 | 517 |
if (Ammoz[a].Ammo.NumPerTurn >= MultiShootAttacks) |
518 |
or ((GameFlags and gfMultiWeapon) <> 0) then |
|
519 |
begin |
|
520 |
isInMultiShoot:= true |
|
521 |
end |
|
522 |
else |
|
523 |
begin |
|
524 |
OnUsedAmmo(CurrentHedgehog^); |
|
525 |
if ((Ammoz[a].Ammo.Propz and ammoprop_NoRoundEnd) = 0) and (((GameFlags and gfInfAttack) = 0) or PlacingHogs) then |
|
526 |
begin |
|
527 |
if TagTurnTimeLeft = 0 then |
|
528 |
TagTurnTimeLeft:= TurnTimeLeft; |
|
8992
5b0be812dcdb
Rename submersible state, increase getaway time for attack underwater, slow down gear dx/dy underwater to simulate water resistance
nemo
parents:
8987
diff
changeset
|
529 |
if (CurAmmoGear <> nil) and (CurAmmoGear^.State and gstSubmersible <> 0) and (hwRound(CurAmmoGear^.Y) > cWaterLine) then |
5b0be812dcdb
Rename submersible state, increase getaway time for attack underwater, slow down gear dx/dy underwater to simulate water resistance
nemo
parents:
8987
diff
changeset
|
530 |
TurnTimeLeft:=(Ammoz[a].TimeAfterTurn * cGetAwayTime) div 25 |
5b0be812dcdb
Rename submersible state, increase getaway time for attack underwater, slow down gear dx/dy underwater to simulate water resistance
nemo
parents:
8987
diff
changeset
|
531 |
else TurnTimeLeft:=(Ammoz[a].TimeAfterTurn * cGetAwayTime) div 100; |
6581 | 532 |
end; |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
533 |
if ((Ammoz[a].Ammo.Propz and ammoprop_NoRoundEnd) = 0) and (HHGear <> nil) then |
7462 | 534 |
HHGear^.State:= HHGear^.State or gstAttacked; |
6581 | 535 |
if (Ammoz[a].Ammo.Propz and ammoprop_NoRoundEnd) <> 0 then |
536 |
ApplyAmmoChanges(CurrentHedgehog^) |
|
537 |
end; |
|
538 |
end |
|
539 |
else |
|
540 |
begin |
|
541 |
OnUsedAmmo(CurrentHedgehog^); |
|
542 |
ApplyAmmoChanges(CurrentHedgehog^); |
|
543 |
end; |
|
544 |
AttackBar:= 0 |
|
545 |
end |
|
546 |
end; |
|
547 |
||
548 |
//////////////////////////////////////////////////////////////////////////////// |
|
549 |
procedure doStepHedgehogDead(Gear: PGear); |
|
550 |
const frametime = 200; |
|
551 |
timertime = frametime * 6; |
|
552 |
begin |
|
553 |
if Gear^.Hedgehog^.Unplaced then |
|
554 |
exit; |
|
555 |
if Gear^.Timer > 1 then |
|
556 |
begin |
|
557 |
AllInactive:= false; |
|
558 |
dec(Gear^.Timer); |
|
559 |
if (Gear^.Timer mod frametime) = 0 then |
|
560 |
inc(Gear^.Pos) |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
561 |
end |
6581 | 562 |
else if Gear^.Timer = 1 then |
563 |
begin |
|
9064 | 564 |
Gear^.Hedgehog^.Effects[heFrozen]:= 0; |
6581 | 565 |
Gear^.State:= Gear^.State or gstNoDamage; |
566 |
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 30, CurrentHedgehog, EXPLAutoSound); |
|
567 |
AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtGrave, 0, _0, _0, 0)^.Hedgehog:= Gear^.Hedgehog; |
|
568 |
DeleteGear(Gear); |
|
569 |
SetAllToActive |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
570 |
end |
6581 | 571 |
else // Gear^.Timer = 0 |
572 |
begin |
|
573 |
AllInactive:= false; |
|
574 |
Gear^.Z:= cCurrHHZ; |
|
575 |
RemoveGearFromList(Gear); |
|
576 |
InsertGearToList(Gear); |
|
7053 | 577 |
PlaySoundV(sndByeBye, Gear^.Hedgehog^.Team^.voicepack); |
6581 | 578 |
Gear^.Pos:= 0; |
579 |
Gear^.Timer:= timertime |
|
580 |
end |
|
581 |
end; |
|
582 |
||
583 |
//////////////////////////////////////////////////////////////////////////////// |
|
584 |
procedure doStepHedgehogGone(Gear: PGear); |
|
585 |
const frametime = 65; |
|
586 |
timertime = frametime * 11; |
|
587 |
begin |
|
588 |
if Gear^.Hedgehog^.Unplaced then |
|
589 |
exit; |
|
590 |
if Gear^.Timer > 1 then |
|
591 |
begin |
|
592 |
AllInactive:= false; |
|
593 |
dec(Gear^.Timer); |
|
594 |
if (Gear^.Timer mod frametime) = 0 then |
|
595 |
inc(Gear^.Pos) |
|
596 |
end |
|
597 |
else |
|
598 |
if Gear^.Timer = 1 then |
|
599 |
begin |
|
600 |
DeleteGear(Gear); |
|
601 |
SetAllToActive |
|
602 |
end |
|
603 |
else // Gear^.Timer = 0 |
|
604 |
begin |
|
605 |
AllInactive:= false; |
|
606 |
Gear^.Z:= cCurrHHZ; |
|
607 |
RemoveGearFromList(Gear); |
|
608 |
InsertGearToList(Gear); |
|
7053 | 609 |
PlaySoundV(sndByeBye, Gear^.Hedgehog^.Team^.voicepack); |
6581 | 610 |
PlaySound(sndWarp); |
611 |
Gear^.Pos:= 0; |
|
612 |
Gear^.Timer:= timertime |
|
613 |
end |
|
614 |
end; |
|
615 |
||
7389
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
616 |
procedure AddPickup(HH: THedgehog; ammo: TAmmoType; cnt, X, Y: LongWord); |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
617 |
var s: shortstring; |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
618 |
vga: PVisualGear; |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
619 |
begin |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
620 |
if cnt <> 0 then AddAmmo(HH, ammo, cnt) |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
621 |
else AddAmmo(HH, ammo); |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
622 |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
623 |
if (not (HH.Team^.ExtDriven |
7389
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
624 |
or (HH.BotLevel > 0))) |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
625 |
or (HH.Team^.Clan^.ClanIndex = LocalClan) |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
626 |
or (GameType = gmtDemo) then |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
627 |
begin |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
628 |
if cnt <> 0 then |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
629 |
s:= trammo[Ammoz[ammo].NameId] + ' (+' + IntToStr(cnt) + ')' |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
630 |
else |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
631 |
s:= trammo[Ammoz[ammo].NameId] + ' (+' + IntToStr(Ammoz[ammo].NumberInCase) + ')'; |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
632 |
AddCaption(s, HH.Team^.Clan^.Color, capgrpAmmoinfo); |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
633 |
|
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
634 |
// show ammo icon |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
635 |
vga:= AddVisualGear(X, Y, vgtAmmo); |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
636 |
if vga <> nil then |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
637 |
vga^.Frame:= Longword(ammo); |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
638 |
end; |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
639 |
end; |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
640 |
|
6581 | 641 |
//////////////////////////////////////////////////////////////////////////////// |
642 |
procedure PickUp(HH, Gear: PGear); |
|
643 |
var s: shortstring; |
|
7406
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset
|
644 |
i: LongInt; |
6581 | 645 |
vga: PVisualGear; |
7406
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset
|
646 |
ag, gi: PGear; |
6581 | 647 |
begin |
648 |
Gear^.Message:= gmDestroy; |
|
649 |
if (Gear^.Pos and posCaseExplode) <> 0 then |
|
650 |
if (Gear^.Pos and posCasePoison) <> 0 then |
|
651 |
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 25, HH^.Hedgehog, EXPLAutoSound + EXPLPoisoned) |
|
652 |
else |
|
653 |
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 25, HH^.Hedgehog, EXPLAutoSound) |
|
654 |
else if (Gear^.Pos and posCasePoison) <> 0 then |
|
655 |
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 25, HH^.Hedgehog, EXPLAutoSound + EXPLPoisoned + EXPLNoDamage) |
|
656 |
else |
|
657 |
case Gear^.Pos of |
|
658 |
posCaseUtility, |
|
659 |
posCaseAmmo: begin |
|
7597
1ef520fea21c
make cheating a bit easier (mikade insisted). Also, try flipping dust for a bit more variety.
nemo
parents:
7462
diff
changeset
|
660 |
PlaySound(sndShotgunReload); |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
661 |
if Gear^.AmmoType <> amNothing then |
7389
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
662 |
begin |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
663 |
AddPickup(HH^.Hedgehog^, Gear^.AmmoType, Gear^.Power, hwRound(Gear^.X), hwRound(Gear^.Y)); |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
664 |
end |
6581 | 665 |
else |
666 |
begin |
|
7389
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
667 |
// Add spawning here... |
7409 | 668 |
AddRandomness(GameTicks); |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
669 |
|
7406
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset
|
670 |
gi := GearsList; |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset
|
671 |
while gi <> nil do |
7391
588eabb4b384
Apparently order of multiple getrandom in params is undefined. Also remove broken and pointless getrandom call.
nemo
parents:
7389
diff
changeset
|
672 |
begin |
8030
165aeaaaf445
Call fallers less often. Should hopefully still be about as effective at the intended purpose. Should help loads quite a bit.
nemo
parents:
8003
diff
changeset
|
673 |
if (gi^.Kind = gtGenericFaller) and (gi^.State and gstInvisible <> 0) then |
7406
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset
|
674 |
begin |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset
|
675 |
gi^.Active:= true; |
8030
165aeaaaf445
Call fallers less often. Should hopefully still be about as effective at the intended purpose. Should help loads quite a bit.
nemo
parents:
8003
diff
changeset
|
676 |
gi^.State:= gi^.State or gstTmpFlag; |
7406
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset
|
677 |
gi^.X:= int2hwFloat(GetRandom(rightX-leftX)+leftX); |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset
|
678 |
gi^.Y:= int2hwFloat(GetRandom(LAND_HEIGHT-topY)+topY); |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset
|
679 |
gi^.dX:= _90-(GetRandomf*_360); |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset
|
680 |
gi^.dY:= _90-(GetRandomf*_360) |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset
|
681 |
end; |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset
|
682 |
gi := gi^.NextGear |
7391
588eabb4b384
Apparently order of multiple getrandom in params is undefined. Also remove broken and pointless getrandom call.
nemo
parents:
7389
diff
changeset
|
683 |
end; |
7598 | 684 |
ag:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtAddAmmo, gstInvisible, _0, _0, GetRandom(125)+25); |
7389
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
685 |
ag^.Pos:= Gear^.Pos; |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
686 |
ag^.Power:= Gear^.Power |
6581 | 687 |
end; |
688 |
end; |
|
689 |
posCaseHealth: begin |
|
7389
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
690 |
PlaySound(sndShotgunReload); |
6581 | 691 |
inc(HH^.Health, Gear^.Health); |
7010
10a0a31804f3
Switch effects to longint for convenience of tracking ice states. I could add a new Hedgehog value, but since we have this effects list being all useless as booleans anyway...
nemo
parents:
6992
diff
changeset
|
692 |
HH^.Hedgehog^.Effects[hePoisoned] := 0; |
6581 | 693 |
str(Gear^.Health, s); |
694 |
s:= '+' + s; |
|
695 |
AddCaption(s, HH^.Hedgehog^.Team^.Clan^.Color, capgrpAmmoinfo); |
|
696 |
RenderHealth(HH^.Hedgehog^); |
|
697 |
RecountTeamHealth(HH^.Hedgehog^.Team); |
|
698 |
||
699 |
i:= 0; |
|
700 |
while i < Gear^.Health do |
|
701 |
begin |
|
702 |
vga:= AddVisualGear(hwRound(HH^.X), hwRound(HH^.Y), vgtStraightShot); |
|
703 |
if vga <> nil then |
|
704 |
with vga^ do |
|
705 |
begin |
|
706 |
Tint:= $00FF00FF; |
|
707 |
State:= ord(sprHealth) |
|
708 |
end; |
|
709 |
inc(i, 5); |
|
710 |
end; |
|
711 |
end; |
|
712 |
end |
|
713 |
end; |
|
714 |
||
715 |
procedure HedgehogStep(Gear: PGear); |
|
716 |
var PrevdX: LongInt; |
|
717 |
CurWeapon: PAmmo; |
|
718 |
begin |
|
6924 | 719 |
CurWeapon:= GetCurAmmoEntry(Gear^.Hedgehog^); |
6581 | 720 |
if ((Gear^.State and (gstAttacking or gstMoving)) = 0) then |
721 |
begin |
|
722 |
if isCursorVisible then |
|
723 |
with Gear^.Hedgehog^ do |
|
724 |
with CurWeapon^ do |
|
725 |
begin |
|
726 |
if (Gear^.Message and gmLeft ) <> 0 then |
|
727 |
Pos:= (Pos - 1 + Ammoz[AmmoType].PosCount) mod Ammoz[AmmoType].PosCount |
|
728 |
else |
|
729 |
if (Gear^.Message and gmRight ) <> 0 then |
|
730 |
Pos:= (Pos + 1) mod Ammoz[AmmoType].PosCount |
|
731 |
else |
|
732 |
exit; |
|
7028 | 733 |
GHStepTicks:= 200; |
6581 | 734 |
exit |
735 |
end; |
|
736 |
||
737 |
if ((Gear^.Message and gmAnimate) <> 0) then |
|
738 |
begin |
|
739 |
Gear^.Message:= 0; |
|
740 |
Gear^.State:= Gear^.State or gstAnimation; |
|
741 |
Gear^.Tag:= Gear^.MsgParam; |
|
742 |
Gear^.Timer:= 0; |
|
743 |
Gear^.Pos:= 0 |
|
744 |
end; |
|
745 |
||
746 |
if ((Gear^.Message and gmLJump ) <> 0) then |
|
747 |
begin |
|
748 |
Gear^.Message:= Gear^.Message and (not gmLJump); |
|
749 |
DeleteCI(Gear); |
|
750 |
if TestCollisionYwithGear(Gear, -1) = 0 then |
|
751 |
if not TestCollisionXwithXYShift(Gear, _0, -2, hwSign(Gear^.dX)) then |
|
752 |
Gear^.Y:= Gear^.Y - _2 |
|
753 |
else |
|
754 |
if not TestCollisionXwithXYShift(Gear, _0, -1, hwSign(Gear^.dX)) then |
|
755 |
Gear^.Y:= Gear^.Y - _1; |
|
756 |
if not (TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) |
|
757 |
or (TestCollisionYwithGear(Gear, -1) <> 0)) then |
|
758 |
begin |
|
759 |
Gear^.dY:= -_0_15; |
|
760 |
if not cArtillery then |
|
761 |
Gear^.dX:= SignAs(_0_15, Gear^.dX); |
|
762 |
Gear^.State:= Gear^.State or gstMoving or gstHHJumping; |
|
7053 | 763 |
PlaySoundV(sndJump1, Gear^.Hedgehog^.Team^.voicepack); |
6581 | 764 |
exit |
765 |
end; |
|
766 |
end; |
|
767 |
||
768 |
if ((Gear^.Message and gmHJump ) <> 0) then |
|
769 |
begin |
|
770 |
DeleteCI(Gear); |
|
771 |
Gear^.Message:= Gear^.Message and (not gmHJump); |
|
772 |
||
773 |
Gear^.dY:= -_0_2; |
|
774 |
SetLittle(Gear^.dX); |
|
775 |
Gear^.State:= Gear^.State or gstMoving or gstHHJumping; |
|
7053 | 776 |
PlaySoundV(sndJump3, Gear^.Hedgehog^.Team^.voicepack); |
6581 | 777 |
exit |
778 |
end; |
|
779 |
||
780 |
PrevdX:= hwSign(Gear^.dX); |
|
781 |
if (Gear^.Message and gmLeft )<>0 then |
|
782 |
Gear^.dX:= -cLittle else |
|
783 |
if (Gear^.Message and gmRight )<>0 then |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
784 |
Gear^.dX:= cLittle |
7187
aff30d80bd7b
- Allow camera movement while current hedgehog is falling
unc0rr
parents:
7164
diff
changeset
|
785 |
else exit; |
6581 | 786 |
|
7187
aff30d80bd7b
- Allow camera movement while current hedgehog is falling
unc0rr
parents:
7164
diff
changeset
|
787 |
StepSoundTimer:= cHHStepTicks; |
7719
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7671
diff
changeset
|
788 |
|
7028 | 789 |
GHStepTicks:= cHHStepTicks; |
6581 | 790 |
if PrevdX <> hwSign(Gear^.dX) then |
791 |
begin |
|
792 |
FollowGear:= Gear; |
|
793 |
exit |
|
794 |
end; |
|
795 |
DeleteCI(Gear); // must be after exit!! (see previous line) |
|
796 |
||
797 |
Gear^.Hedgehog^.visStepPos:= (Gear^.Hedgehog^.visStepPos + 1) and 7; |
|
7164
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7069
diff
changeset
|
798 |
|
7719
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7671
diff
changeset
|
799 |
if (not cArtillery) and ((Gear^.Message and gmPrecise) = 0) then |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7671
diff
changeset
|
800 |
MakeHedgehogsStep(Gear); |
6581 | 801 |
|
8576
286ebfcb3d97
workaround for frequent AllHH active call in hedgehog step
nemo
parents:
8574
diff
changeset
|
802 |
SetAllHHToActive(false); |
6581 | 803 |
AddGearCI(Gear) |
804 |
end |
|
805 |
end; |
|
806 |
||
807 |
procedure HedgehogChAngle(HHGear: PGear); |
|
808 |
var da: LongWord; |
|
809 |
begin |
|
810 |
with HHGear^.Hedgehog^ do |
|
9139
2ae44c4381cd
Restore CurAmmoType check as well, that was removed in r8f317ba10675 when trying to fix aiming during alt attack.
nemo
parents:
9080
diff
changeset
|
811 |
if (((CurAmmoType = amRope) or ((CurAmmoGear <> nil) and (CurAmmoGear^.AmmoType = amRope))) and |
2ae44c4381cd
Restore CurAmmoType check as well, that was removed in r8f317ba10675 when trying to fix aiming during alt attack.
nemo
parents:
9080
diff
changeset
|
812 |
((HHGear^.State and (gstMoving or gstHHJumping)) = gstMoving)) |
6581 | 813 |
or ((CurAmmoType = amPortalGun) and ((HHGear^.State and gstMoving) <> 0)) then |
814 |
da:= 2 |
|
815 |
else da:= 1; |
|
816 |
||
8987
47cf32305d99
some saucer thing for firing weps underwater and aiming and such. bit drunk and sleepy so testing I guess
nemo
parents:
8947
diff
changeset
|
817 |
if ((HHGear^.Message and gmPrecise = 0) or ((CurAmmoGear <> nil) and (CurAmmoGear^.AmmoType = amJetpack))) or (GameTicks mod 5 = 1) then |
6581 | 818 |
if ((HHGear^.Message and gmUp) <> 0) and (HHGear^.Angle >= CurMinAngle + da) then |
819 |
dec(HHGear^.Angle, da) |
|
820 |
else |
|
821 |
if ((HHGear^.Message and gmDown) <> 0) and (HHGear^.Angle + da <= CurMaxAngle) then |
|
822 |
inc(HHGear^.Angle, da) |
|
823 |
end; |
|
824 |
||
825 |
||
826 |
//////////////////////////////////////////////////////////////////////////////// |
|
827 |
procedure doStepHedgehogMoving(Gear: PGear); |
|
828 |
var isFalling, isUnderwater: boolean; |
|
829 |
land: Word; |
|
830 |
begin |
|
831 |
land:= 0; |
|
832 |
isUnderwater:= cWaterLine < hwRound(Gear^.Y) + Gear^.Radius; |
|
833 |
if Gear^.dX.QWordValue > 8160437862 then |
|
834 |
Gear^.dX.QWordValue:= 8160437862; |
|
835 |
if Gear^.dY.QWordValue > 8160437862 then |
|
836 |
Gear^.dY.QWordValue:= 8160437862; |
|
837 |
||
838 |
if Gear^.Hedgehog^.Unplaced then |
|
839 |
begin |
|
840 |
Gear^.dY:= _0; |
|
841 |
Gear^.dX:= _0; |
|
842 |
Gear^.State:= Gear^.State and (not gstMoving); |
|
843 |
exit |
|
844 |
end; |
|
7426
55b49cc1f33a
Changes for the benefit of pas2c. Use downto in for loops to avoid repeated calls of Random/GetRandom. Wrap nots.
nemo
parents:
7409
diff
changeset
|
845 |
isFalling:= (Gear^.dY.isNegative) or (not TestCollisionYKick(Gear, 1)); |
6581 | 846 |
if isFalling then |
847 |
begin |
|
848 |
if (Gear^.dY.isNegative) and TestCollisionYKick(Gear, -1) then |
|
849 |
Gear^.dY:= _0; |
|
850 |
Gear^.State:= Gear^.State or gstMoving; |
|
851 |
if (CurrentHedgehog^.Gear = Gear) |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
852 |
and (hwSqr(Gear^.dX) + hwSqr(Gear^.dY) > _0_003) then |
6581 | 853 |
begin |
7187
aff30d80bd7b
- Allow camera movement while current hedgehog is falling
unc0rr
parents:
7164
diff
changeset
|
854 |
// TODO: why so aggressive at setting FollowGear when falling? |
6581 | 855 |
FollowGear:= Gear; |
856 |
end; |
|
857 |
if isUnderwater then |
|
858 |
Gear^.dY:= Gear^.dY + cGravity / _2 |
|
859 |
else |
|
860 |
begin |
|
861 |
Gear^.dY:= Gear^.dY + cGravity; |
|
862 |
// this set of circumstances could be less complex if jumping was more clearly identified |
|
863 |
if ((GameFlags and gfMoreWind) <> 0) and (((Gear^.Damage <> 0) |
|
864 |
or ((CurAmmoGear <> nil) and ((CurAmmoGear^.AmmoType = amJetpack) or (CurAmmoGear^.AmmoType = amBirdy))) |
|
865 |
or ((Gear^.dY.QWordValue + Gear^.dX.QWordValue) > _0_55.QWordValue))) then |
|
866 |
Gear^.dX := Gear^.dX + cWindSpeed / Gear^.Density |
|
867 |
end |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
868 |
end |
6581 | 869 |
else |
870 |
begin |
|
871 |
land:= TestCollisionYwithGear(Gear, 1); |
|
872 |
if ((Gear^.dX.QWordValue + Gear^.dY.QWordValue) < _0_55.QWordValue) and ((land and lfIce) = 0) |
|
873 |
and ((Gear^.State and gstHHJumping) <> 0) then |
|
874 |
SetLittle(Gear^.dX); |
|
875 |
||
876 |
if not Gear^.dY.isNegative then |
|
877 |
begin |
|
878 |
CheckHHDamage(Gear); |
|
879 |
||
880 |
if ((Gear^.State and gstHHHJump) <> 0) and (not cArtillery) |
|
881 |
and (Gear^.dX.QWordValue < _0_02.QWordValue) then |
|
882 |
Gear^.dX.isNegative:= not Gear^.dX.isNegative; // landing after high jump |
|
883 |
Gear^.State:= Gear^.State and (not (gstHHJumping or gstHHHJump)); |
|
884 |
Gear^.dY:= _0; |
|
885 |
end |
|
886 |
else |
|
887 |
Gear^.dY:= Gear^.dY + cGravity; |
|
888 |
||
889 |
if ((Gear^.State and gstMoving) <> 0) then |
|
890 |
begin |
|
891 |
if land and lfIce <> 0 then |
|
892 |
begin |
|
893 |
Gear^.dX:= Gear^.dX * (_1 - (_1 - Gear^.Friction) / _2) |
|
894 |
end |
|
895 |
else |
|
896 |
Gear^.dX:= Gear^.dX * Gear^.Friction; |
|
897 |
end |
|
898 |
end; |
|
899 |
||
900 |
if (Gear^.State <> 0) then |
|
901 |
DeleteCI(Gear); |
|
902 |
||
903 |
if isUnderwater then |
|
904 |
begin |
|
905 |
Gear^.dY:= Gear^.dY * _0_999; |
|
906 |
Gear^.dX:= Gear^.dX * _0_999; |
|
907 |
end; |
|
908 |
||
909 |
if (Gear^.State and gstMoving) <> 0 then |
|
910 |
if TestCollisionXKick(Gear, hwSign(Gear^.dX)) then |
|
911 |
if not isFalling then |
|
912 |
if hwAbs(Gear^.dX) > _0_01 then |
|
8753
1dfc456b7d50
fix ancient issue with hedgehogs sliding through/into think gaps; fixes issue 542; could and should be optimized (also to make sure that hogs can't slide through little pixel turds) - feel free to do so =P
sheepluva
parents:
8744
diff
changeset
|
913 |
if not (TestCollisionXwithXYShift(Gear, int2hwFloat(hwSign(Gear^.dX)) - Gear^.dX, -1, hwSign(Gear^.dX)) or |
1dfc456b7d50
fix ancient issue with hedgehogs sliding through/into think gaps; fixes issue 542; could and should be optimized (also to make sure that hogs can't slide through little pixel turds) - feel free to do so =P
sheepluva
parents:
8744
diff
changeset
|
914 |
(TestCollisionYwithXYShift(Gear, hwSign(Gear^.dX) - hwRound(Gear^.dX), -1, -1))) then |
6581 | 915 |
begin |
916 |
Gear^.X:= Gear^.X + Gear^.dX; |
|
917 |
Gear^.dX:= Gear^.dX * _0_96; |
|
918 |
Gear^.Y:= Gear^.Y - _1 |
|
919 |
end |
|
920 |
else |
|
8753
1dfc456b7d50
fix ancient issue with hedgehogs sliding through/into think gaps; fixes issue 542; could and should be optimized (also to make sure that hogs can't slide through little pixel turds) - feel free to do so =P
sheepluva
parents:
8744
diff
changeset
|
921 |
if not (TestCollisionXwithXYShift(Gear, int2hwFloat(hwSign(Gear^.dX)) - Gear^.dX, -2, hwSign(Gear^.dX)) or |
1dfc456b7d50
fix ancient issue with hedgehogs sliding through/into think gaps; fixes issue 542; could and should be optimized (also to make sure that hogs can't slide through little pixel turds) - feel free to do so =P
sheepluva
parents:
8744
diff
changeset
|
922 |
(TestCollisionYwithXYShift(Gear, hwSign(Gear^.dX) - hwRound(Gear^.dX), -1, -1))) then |
6581 | 923 |
begin |
924 |
Gear^.X:= Gear^.X + Gear^.dX; |
|
925 |
Gear^.dX:= Gear^.dX * _0_93; |
|
926 |
Gear^.Y:= Gear^.Y - _2 |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
927 |
end |
6581 | 928 |
else |
8753
1dfc456b7d50
fix ancient issue with hedgehogs sliding through/into think gaps; fixes issue 542; could and should be optimized (also to make sure that hogs can't slide through little pixel turds) - feel free to do so =P
sheepluva
parents:
8744
diff
changeset
|
929 |
if not (TestCollisionXwithXYShift(Gear, int2hwFloat(hwSign(Gear^.dX)) - Gear^.dX, -3, hwSign(Gear^.dX)) or |
1dfc456b7d50
fix ancient issue with hedgehogs sliding through/into think gaps; fixes issue 542; could and should be optimized (also to make sure that hogs can't slide through little pixel turds) - feel free to do so =P
sheepluva
parents:
8744
diff
changeset
|
930 |
(TestCollisionYwithXYShift(Gear, hwSign(Gear^.dX) - hwRound(Gear^.dX), -1, -1))) then |
6581 | 931 |
begin |
932 |
Gear^.X:= Gear^.X + Gear^.dX; |
|
933 |
Gear^.dX:= Gear^.dX * _0_9 ; |
|
934 |
Gear^.Y:= Gear^.Y - _3 |
|
935 |
end |
|
936 |
else |
|
8753
1dfc456b7d50
fix ancient issue with hedgehogs sliding through/into think gaps; fixes issue 542; could and should be optimized (also to make sure that hogs can't slide through little pixel turds) - feel free to do so =P
sheepluva
parents:
8744
diff
changeset
|
937 |
if not (TestCollisionXwithXYShift(Gear, int2hwFloat(hwSign(Gear^.dX)) - Gear^.dX, -4, hwSign(Gear^.dX)) or |
1dfc456b7d50
fix ancient issue with hedgehogs sliding through/into think gaps; fixes issue 542; could and should be optimized (also to make sure that hogs can't slide through little pixel turds) - feel free to do so =P
sheepluva
parents:
8744
diff
changeset
|
938 |
(TestCollisionYwithXYShift(Gear, hwSign(Gear^.dX) - hwRound(Gear^.dX), -1, -1))) then |
6581 | 939 |
begin |
940 |
Gear^.X:= Gear^.X + Gear^.dX; |
|
941 |
Gear^.dX:= Gear^.dX * _0_87; |
|
942 |
Gear^.Y:= Gear^.Y - _4 |
|
943 |
end |
|
944 |
else |
|
8753
1dfc456b7d50
fix ancient issue with hedgehogs sliding through/into think gaps; fixes issue 542; could and should be optimized (also to make sure that hogs can't slide through little pixel turds) - feel free to do so =P
sheepluva
parents:
8744
diff
changeset
|
945 |
if not (TestCollisionXwithXYShift(Gear, int2hwFloat(hwSign(Gear^.dX)) - Gear^.dX, -5, hwSign(Gear^.dX)) or |
1dfc456b7d50
fix ancient issue with hedgehogs sliding through/into think gaps; fixes issue 542; could and should be optimized (also to make sure that hogs can't slide through little pixel turds) - feel free to do so =P
sheepluva
parents:
8744
diff
changeset
|
946 |
(TestCollisionYwithXYShift(Gear, hwSign(Gear^.dX) - hwRound(Gear^.dX), -1, -1))) then |
6581 | 947 |
begin |
948 |
Gear^.X:= Gear^.X + Gear^.dX; |
|
949 |
Gear^.dX:= Gear^.dX * _0_84; |
|
950 |
Gear^.Y:= Gear^.Y - _5 |
|
951 |
end |
|
952 |
else |
|
953 |
if hwAbs(Gear^.dX) > _0_02 then |
|
954 |
Gear^.dX:= -Gear^.Elasticity * Gear^.dX |
|
955 |
else |
|
956 |
begin |
|
957 |
Gear^.State:= Gear^.State and (not gstMoving); |
|
958 |
while TestCollisionYWithGear(Gear,1) = 0 do |
|
959 |
Gear^.Y:= Gear^.Y+_1; |
|
960 |
SetLittle(Gear^.dX) |
|
961 |
end |
|
962 |
else |
|
963 |
begin |
|
964 |
Gear^.State:= Gear^.State and (not gstMoving); |
|
965 |
while TestCollisionYWithGear(Gear,1) = 0 do |
|
966 |
Gear^.Y:= Gear^.Y+_1; |
|
967 |
SetLittle(Gear^.dX) |
|
968 |
end |
|
969 |
else if (hwAbs(Gear^.dX) > cLittle) |
|
970 |
and ((Gear^.State and gstHHJumping) = 0) then |
|
971 |
Gear^.dX:= -Gear^.Elasticity * Gear^.dX |
|
972 |
else |
|
973 |
SetLittle(Gear^.dX); |
|
974 |
||
975 |
if (not isFalling) |
|
7362
53bcfc714cb3
Fix rare condition when hog's gear stucks in an infinite loop which adds 1 to its Y coordinate not checking for drowning
unc0rr
parents:
7339
diff
changeset
|
976 |
and (hwAbs(Gear^.dX) + hwAbs(Gear^.dY) < _0_03) then |
6581 | 977 |
begin |
978 |
Gear^.State:= Gear^.State and (not gstWinner); |
|
979 |
Gear^.State:= Gear^.State and (not gstMoving); |
|
8947
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8818
diff
changeset
|
980 |
while (TestCollisionYWithGear(Gear,1) = 0) and (not CheckGearDrowning(Gear)) and (Gear <> nil) do |
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8818
diff
changeset
|
981 |
Gear^.Y:= Gear^.Y + _1; |
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8818
diff
changeset
|
982 |
|
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8818
diff
changeset
|
983 |
// could become nil in CheckGearDrowning if ai's hog fails to respawn in ai survival |
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8818
diff
changeset
|
984 |
if Gear = nil then exit; |
6581 | 985 |
SetLittle(Gear^.dX); |
986 |
Gear^.dY:= _0 |
|
987 |
end |
|
988 |
else |
|
989 |
Gear^.State:= Gear^.State or gstMoving; |
|
990 |
||
991 |
if (Gear^.State and gstMoving) <> 0 then |
|
992 |
begin |
|
993 |
Gear^.State:= Gear^.State and (not gstAnimation); |
|
994 |
// ARTILLERY but not being moved by explosions |
|
995 |
Gear^.X:= Gear^.X + Gear^.dX; |
|
996 |
Gear^.Y:= Gear^.Y + Gear^.dY; |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
997 |
if (not Gear^.dY.isNegative) and (not TestCollisionYKick(Gear, 1)) |
6581 | 998 |
and TestCollisionYwithXYShift(Gear, 0, 1, 1) then |
999 |
begin |
|
1000 |
CheckHHDamage(Gear); |
|
1001 |
Gear^.dY:= _0; |
|
1002 |
Gear^.Y:= Gear^.Y + _1 |
|
1003 |
end; |
|
8947
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8818
diff
changeset
|
1004 |
|
6581 | 1005 |
CheckGearDrowning(Gear); |
8947
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8818
diff
changeset
|
1006 |
// could become nil if ai's hog fails to respawn in ai survival |
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8818
diff
changeset
|
1007 |
if Gear = nil then exit; |
6581 | 1008 |
// hide target cursor if current hog is drowning |
1009 |
if (Gear^.State and gstDrowning) <> 0 then |
|
1010 |
if (CurrentHedgehog^.Gear = Gear) then |
|
1011 |
isCursorVisible:= false |
|
1012 |
end; |
|
7623
addc5b262617
isZero appears to be never used. Use it in a few obvious cases and add web variant.
nemo
parents:
7615
diff
changeset
|
1013 |
if (not isZero(Gear^.dY)) and (Gear^.FlightTime > 0) and ((GameFlags and gfLowGravity) = 0) then |
6581 | 1014 |
begin |
1015 |
inc(Gear^.FlightTime); |
|
8003 | 1016 |
if (Gear^.FlightTime > 1500) and ((hwRound(Gear^.X) < LongInt(leftX)-250) or (hwRound(Gear^.X) > LongInt(rightX)+250)) then |
6581 | 1017 |
begin |
7763 | 1018 |
Gear^.FlightTime:= 0; |
6581 | 1019 |
AddCaption(GetEventString(eidHomerun), cWhiteColor, capgrpMessage); |
1020 |
PlaySound(sndHomerun) |
|
1021 |
end; |
|
1022 |
end |
|
1023 |
else |
|
1024 |
begin |
|
1025 |
uStats.hedgehogFlight(Gear, Gear^.FlightTime); |
|
1026 |
Gear^.FlightTime:= 0; |
|
1027 |
end; |
|
1028 |
||
1029 |
end; |
|
1030 |
||
1031 |
procedure doStepHedgehogDriven(HHGear: PGear); |
|
1032 |
var t: PGear; |
|
1033 |
wasJumping: boolean; |
|
1034 |
Hedgehog: PHedgehog; |
|
1035 |
begin |
|
1036 |
Hedgehog:= HHGear^.Hedgehog; |
|
8658 | 1037 |
if not isInMultiShoot then |
1038 |
AllInactive:= false |
|
1039 |
else if Hedgehog^.CurAmmoType in [amShotgun, amDEagle, amSniperRifle] then |
|
1040 |
HHGear^.Message:= 0; |
|
6581 | 1041 |
|
1042 |
if (TurnTimeLeft = 0) or (HHGear^.Damage > 0) then |
|
1043 |
begin |
|
8494
53b91a602955
Cleaver tweaks based on feedback. Nerf damage, shrink radius. This means cleaver will embed into ground quite a bit further.
nemo
parents:
8493
diff
changeset
|
1044 |
if (Hedgehog^.CurAmmoType = amKnife) then |
53b91a602955
Cleaver tweaks based on feedback. Nerf damage, shrink radius. This means cleaver will embed into ground quite a bit further.
nemo
parents:
8493
diff
changeset
|
1045 |
LoadHedgehogHat(Hedgehog^, Hedgehog^.Hat); |
6581 | 1046 |
if TagTurnTimeLeft = 0 then |
1047 |
TagTurnTimeLeft:= TurnTimeLeft; |
|
1048 |
TurnTimeLeft:= 0; |
|
1049 |
isCursorVisible:= false; |
|
1050 |
HHGear^.State:= HHGear^.State and (not (gstHHDriven or gstAnimation or gstAttacking)); |
|
1051 |
AttackBar:= 0; |
|
1052 |
if HHGear^.Damage > 0 then |
|
1053 |
HHGear^.State:= HHGear^.State and (not (gstHHJumping or gstHHHJump)); |
|
1054 |
exit |
|
1055 |
end; |
|
1056 |
||
1057 |
if (HHGear^.State and gstAnimation) <> 0 then |
|
1058 |
begin |
|
1059 |
HHGear^.Message:= 0; |
|
1060 |
if (HHGear^.Pos = Wavez[TWave(HHGear^.Tag)].VoiceDelay) and (HHGear^.Timer = 0) then |
|
7053 | 1061 |
PlaySoundV(Wavez[TWave(HHGear^.Tag)].Voice, Hedgehog^.Team^.voicepack); |
6581 | 1062 |
inc(HHGear^.Timer); |
1063 |
if HHGear^.Timer = Wavez[TWave(HHGear^.Tag)].Interval then |
|
1064 |
begin |
|
1065 |
HHGear^.Timer:= 0; |
|
1066 |
inc(HHGear^.Pos); |
|
1067 |
if HHGear^.Pos = Wavez[TWave(HHGear^.Tag)].FramesCount then |
|
1068 |
HHGear^.State:= HHGear^.State and (not gstAnimation) |
|
1069 |
end; |
|
1070 |
exit |
|
1071 |
end; |
|
1072 |
||
1073 |
if ((HHGear^.State and gstMoving) <> 0) |
|
7028 | 1074 |
or (GHStepTicks = cHHStepTicks) |
6581 | 1075 |
or (CurAmmoGear <> nil) then // we are moving |
1076 |
begin |
|
1077 |
with Hedgehog^ do |
|
1078 |
if (CurAmmoGear = nil) |
|
1079 |
and (HHGear^.dY > _0_39) |
|
1080 |
and (CurAmmoType = amParachute) then |
|
1081 |
HHGear^.Message:= HHGear^.Message or gmAttack; |
|
1082 |
// check for case with ammo |
|
1083 |
t:= CheckGearNear(HHGear, gtCase, 36, 36); |
|
9041
aefe46d64dd9
Make frozen crates uncollectable, add some tinting to frozen items. Suggestions needed for what should happen to explosives
nemo
parents:
8992
diff
changeset
|
1084 |
if (t <> nil) and (t^.State and gstFrozen = 0) then |
6581 | 1085 |
PickUp(HHGear, t) |
1086 |
end; |
|
1087 |
||
1088 |
if (CurAmmoGear = nil) then |
|
1089 |
if (((HHGear^.Message and gmAttack) <> 0) |
|
1090 |
or ((HHGear^.State and gstAttacking) <> 0)) then |
|
1091 |
Attack(HHGear) // should be before others to avoid desync with '/put' msg and changing weapon msgs |
|
1092 |
else |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
1093 |
else |
6581 | 1094 |
with Hedgehog^ do |
1095 |
if ((Ammoz[CurAmmoGear^.AmmoType].Ammo.Propz and ammoprop_AltAttack) <> 0) |
|
1096 |
and ((HHGear^.Message and gmLJump) <> 0) |
|
1097 |
and ((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_AltUse) <> 0) then |
|
1098 |
begin |
|
1099 |
Attack(HHGear); |
|
1100 |
HHGear^.Message:= HHGear^.Message and (not gmLJump) |
|
1101 |
end; |
|
1102 |
||
1103 |
if (CurAmmoGear = nil) |
|
7956
61da79e83330
Causes AI fail. Needs testing 'cause at some point, I thought this was needed for portal, I don't remember *why*
nemo
parents:
7832
diff
changeset
|
1104 |
or ((Ammoz[CurAmmoGear^.AmmoType].Ammo.Propz and ammoprop_AltAttack) <> 0) then |
6581 | 1105 |
begin |
1106 |
if ((HHGear^.Message and gmSlot) <> 0) then |
|
1107 |
if ChangeAmmo(HHGear) then ApplyAmmoChanges(Hedgehog^); |
|
1108 |
||
1109 |
if ((HHGear^.Message and gmWeapon) <> 0) then |
|
1110 |
HHSetWeapon(HHGear); |
|
1111 |
||
1112 |
if ((HHGear^.Message and gmTimer) <> 0) then |
|
1113 |
HHSetTimer(HHGear); |
|
1114 |
end; |
|
1115 |
||
1116 |
if CurAmmoGear <> nil then |
|
1117 |
begin |
|
1118 |
CurAmmoGear^.Message:= HHGear^.Message; |
|
1119 |
exit |
|
1120 |
end; |
|
1121 |
||
1122 |
HedgehogChAngle(HHGear); |
|
1123 |
||
1124 |
if (HHGear^.State and gstMoving) <> 0 then |
|
1125 |
begin |
|
1126 |
wasJumping:= ((HHGear^.State and gstHHJumping) <> 0); |
|
1127 |
||
1128 |
if ((HHGear^.Message and gmHJump) <> 0) and wasJumping and ((HHGear^.State and gstHHHJump) = 0) then |
|
1129 |
if (not (hwAbs(HHGear^.dX) > cLittle)) and (HHGear^.dY < -_0_02) then |
|
1130 |
begin |
|
1131 |
HHGear^.State:= HHGear^.State or gstHHHJump; |
|
1132 |
HHGear^.dY:= -_0_25; |
|
1133 |
if not cArtillery then |
|
1134 |
HHGear^.dX:= -SignAs(_0_02, HHGear^.dX); |
|
7053 | 1135 |
PlaySoundV(sndJump2, Hedgehog^.Team^.voicepack) |
6581 | 1136 |
end; |
1137 |
||
1138 |
HHGear^.Message:= HHGear^.Message and (not (gmLJump or gmHJump)); |
|
1139 |
||
1140 |
if (not cArtillery) and wasJumping and TestCollisionXwithGear(HHGear, hwSign(HHGear^.dX)) then |
|
1141 |
SetLittle(HHGear^.dX); |
|
1142 |
||
1143 |
if Hedgehog^.Gear <> nil then |
|
1144 |
doStepHedgehogMoving(HHGear); |
|
1145 |
||
1146 |
if ((HHGear^.State and (gstMoving or gstDrowning)) = 0) then |
|
1147 |
begin |
|
1148 |
AddGearCI(HHGear); |
|
1149 |
if wasJumping then |
|
7028 | 1150 |
GHStepTicks:= 410 |
6581 | 1151 |
else |
7028 | 1152 |
GHStepTicks:= 95 |
6581 | 1153 |
end; |
1154 |
exit |
|
1155 |
end; |
|
1156 |
||
8562
d9d1cb650ff8
Restore freezing hedgehog for shotgun, sniper rifle and deagle to make unc0rr happy. You'll still be able to get away after throwing cleaver and sticky bomb tho.
nemo
parents:
8553
diff
changeset
|
1157 |
if not(isInMultiShoot and (Hedgehog^.CurAmmoType in [amShotgun, amDEagle, amSniperRifle])) and (Hedgehog^.Gear <> nil) then |
6581 | 1158 |
begin |
7028 | 1159 |
if GHStepTicks > 0 then |
1160 |
dec(GHStepTicks); |
|
1161 |
if (GHStepTicks = 0) then |
|
6581 | 1162 |
HedgehogStep(HHGear) |
1163 |
end |
|
1164 |
end; |
|
1165 |
||
1166 |
//////////////////////////////////////////////////////////////////////////////// |
|
1167 |
procedure doStepHedgehogFree(Gear: PGear); |
|
1168 |
var prevState: Longword; |
|
1169 |
begin |
|
1170 |
prevState:= Gear^.State; |
|
1171 |
||
1172 |
doStepHedgehogMoving(Gear); |
|
1173 |
||
1174 |
if (Gear^.State and (gstMoving or gstDrowning)) <> 0 then |
|
1175 |
begin |
|
1176 |
if Gear^.Damage > 0 then |
|
1177 |
CalcRotationDirAngle(Gear); |
|
1178 |
AllInactive:= false; |
|
1179 |
exit |
|
1180 |
end; |
|
1181 |
||
1182 |
if (Gear^.Health = 0) then |
|
1183 |
begin |
|
1184 |
if PrvInactive or ((GameFlags and gfInfAttack) <> 0) then |
|
1185 |
begin |
|
1186 |
Gear^.Timer:= 0; |
|
1187 |
FollowGear:= Gear; |
|
1188 |
PrvInactive:= false; |
|
1189 |
AllInactive:= false; |
|
1190 |
||
1191 |
if (Gear^.State and gstHHGone) = 0 then |
|
1192 |
begin |
|
7010
10a0a31804f3
Switch effects to longint for convenience of tracking ice states. I could add a new Hedgehog value, but since we have this effects list being all useless as booleans anyway...
nemo
parents:
6992
diff
changeset
|
1193 |
Gear^.Hedgehog^.Effects[hePoisoned] := 0; |
10a0a31804f3
Switch effects to longint for convenience of tracking ice states. I could add a new Hedgehog value, but since we have this effects list being all useless as booleans anyway...
nemo
parents:
6992
diff
changeset
|
1194 |
if Gear^.Hedgehog^.Effects[heResurrectable] <> 0 then |
6581 | 1195 |
begin |
1196 |
ResurrectHedgehog(Gear); |
|
1197 |
end |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
1198 |
else |
6581 | 1199 |
begin |
1200 |
Gear^.State:= (Gear^.State or gstHHDeath) and (not gstAnimation); |
|
1201 |
Gear^.doStep:= @doStepHedgehogDead; |
|
1202 |
// Death message |
|
1203 |
AddCaption(Format(GetEventString(eidDied), Gear^.Hedgehog^.Name), cWhiteColor, capgrpMessage); |
|
1204 |
end; |
|
1205 |
end |
|
1206 |
else |
|
1207 |
begin |
|
1208 |
Gear^.State:= Gear^.State and (not gstAnimation); |
|
1209 |
Gear^.doStep:= @doStepHedgehogGone; |
|
1210 |
||
1211 |
// Gone message |
|
1212 |
AddCaption(Format(GetEventString(eidGone), Gear^.Hedgehog^.Name), cWhiteColor, capgrpMessage); |
|
1213 |
end |
|
1214 |
end; |
|
1215 |
exit |
|
1216 |
end; |
|
1217 |
||
1218 |
if ((Gear^.State and gstWait) = 0) and |
|
1219 |
(prevState <> Gear^.State) then |
|
1220 |
begin |
|
1221 |
Gear^.State:= Gear^.State or gstWait; |
|
1222 |
Gear^.Timer:= 150 |
|
1223 |
end |
|
1224 |
else |
|
1225 |
begin |
|
1226 |
if Gear^.Timer = 0 then |
|
1227 |
begin |
|
1228 |
Gear^.State:= Gear^.State and (not (gstWait or gstLoser or gstWinner or gstAttacked or gstNotKickable or gstHHChooseTarget)); |
|
8563
4d9d8287e601
Trying to improve rendering, sliding and thawing. Messing around w/ making fire thaw faster.
nemo
parents:
8560
diff
changeset
|
1229 |
if Gear^.Hedgehog^.Effects[heFrozen] = 0 then Gear^.Active:= false; |
6581 | 1230 |
AddGearCI(Gear); |
1231 |
exit |
|
1232 |
end |
|
1233 |
else dec(Gear^.Timer) |
|
1234 |
end; |
|
1235 |
||
1236 |
AllInactive:= false |
|
1237 |
end; |
|
1238 |
||
8574 | 1239 |
procedure CheckIce(Gear: PGear); inline; |
6581 | 1240 |
(* |
1241 |
var x,y,tx,ty: LongInt; |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
1242 |
tdX, tdY, slope: hwFloat; |
6581 | 1243 |
land: Word; *) |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
1244 |
var slope: hwFloat; |
6581 | 1245 |
begin |
8574 | 1246 |
if (Gear^.Message and (gmAllStoppable or gmLJump or gmHJump) = 0) |
1247 |
and (Gear^.State and (gstHHJumping or gstHHHJump or gstAttacking) = 0) |
|
8633 | 1248 |
and ((Gear^.Hedgehog = nil) or ((Gear^.Hedgehog^.Effects[heFrozen] = 0) or (Gear^.Hedgehog^.Effects[heFrozen] > 255))) |
8616
c4536e98c712
Safety check. The main place this can be a problem is on a mild bowl w/ multiple hogs. Could possibly add a hog collision check in here.
nemo
parents:
8589
diff
changeset
|
1249 |
and (not Gear^.dY.isNegative) and (TurnTimeLeft > 0) and (TestCollisionYwithGear(Gear, 1) and lfIce <> 0) then |
8574 | 1250 |
begin |
1251 |
slope:= CalcSlopeBelowGear(Gear); |
|
1252 |
if slope.QWordValue > 730144440 then // ignore mild slopes |
|
1253 |
begin |
|
1254 |
Gear^.dX:=Gear^.dX+slope*cGravity*_256; |
|
1255 |
Gear^.State:= Gear^.State or gstMoving |
|
1256 |
end |
|
1257 |
end; |
|
1258 |
(* |
|
1259 |
x:= hwRound(Gear^.X); |
|
1260 |
y:= hwRound(Gear^.Y); |
|
1261 |
AddVisualGear(x, y, vgtSmokeTrace); |
|
1262 |
AddVisualGear(x - hwRound(_5*slope), y + hwRound(_5*slope), vgtSmokeTrace); |
|
1263 |
AddVisualGear(x + hwRound(_5*slope), y - hwRound(_5*slope), vgtSmokeTrace); |
|
1264 |
AddVisualGear(x - hwRound(_20 * slope), y + hwRound(_20 * slope), vgtSmokeTrace); |
|
1265 |
AddVisualGear(x + hwRound(_20 * slope), y - hwRound(_20 * slope), vgtSmokeTrace); |
|
1266 |
AddVisualGear(x - hwRound(_30 * slope), y + hwRound(_30 * slope), vgtSmokeTrace); |
|
1267 |
AddVisualGear(x + hwRound(_30 * slope), y - hwRound(_30 * slope), vgtSmokeTrace); |
|
1268 |
AddVisualGear(x - hwRound(_40 * slope), y + hwRound(_40 * slope), vgtSmokeTrace); |
|
1269 |
AddVisualGear(x + hwRound(_40 * slope), y - hwRound(_40 * slope), vgtSmokeTrace); |
|
1270 |
AddVisualGear(x - hwRound(_50 * slope), y + hwRound(_50 * slope), vgtSmokeTrace); |
|
1271 |
AddVisualGear(x + hwRound(_50 * slope), y - hwRound(_50 * slope), vgtSmokeTrace); *) |
|
1272 |
end; |
|
1273 |
||
1274 |
//////////////////////////////////////////////////////////////////////////////// |
|
1275 |
procedure doStepHedgehog(Gear: PGear); |
|
1276 |
begin |
|
7389
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7375
diff
changeset
|
1277 |
CheckSum:= CheckSum xor Gear^.Hedgehog^.BotLevel; |
6581 | 1278 |
if (Gear^.Message and gmDestroy) <> 0 then |
1279 |
begin |
|
1280 |
DeleteGear(Gear); |
|
1281 |
exit |
|
1282 |
end; |
|
8576
286ebfcb3d97
workaround for frequent AllHH active call in hedgehog step
nemo
parents:
8574
diff
changeset
|
1283 |
if GameTicks mod 100 = 0 then CheckIce(Gear); |
8655
9fa380a18a65
At multiple requests, change ice to be turn based. This is a more modest adjustment of existing code, that can be fairly easily flagged or reverted if desired. It also allows scripts to extend freezing, and preserves fire melting.
nemo
parents:
8633
diff
changeset
|
1284 |
(* |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
1285 |
if Gear^.Hedgehog^.Effects[heFrozen] > 0 then |
8563
4d9d8287e601
Trying to improve rendering, sliding and thawing. Messing around w/ making fire thaw faster.
nemo
parents:
8560
diff
changeset
|
1286 |
begin |
8632
b5ed76d2a1f9
Make hogs thaw only on enemy turns, make timebox counter decrement only on your turn, adjust knock for frozen hogs, increase damage on frozen hogs, make freezer fuel only reduce when not adjusting angle.
nemo
parents:
8631
diff
changeset
|
1287 |
if (Gear^.Hedgehog^.Effects[heFrozen] > 256) and (CurrentHedgehog^.Team^.Clan <> Gear^.Hedgehog^.Team^.Clan) then |
8563
4d9d8287e601
Trying to improve rendering, sliding and thawing. Messing around w/ making fire thaw faster.
nemo
parents:
8560
diff
changeset
|
1288 |
dec(Gear^.Hedgehog^.Effects[heFrozen]) |
4d9d8287e601
Trying to improve rendering, sliding and thawing. Messing around w/ making fire thaw faster.
nemo
parents:
8560
diff
changeset
|
1289 |
else if GameTicks mod 10 = 0 then |
4d9d8287e601
Trying to improve rendering, sliding and thawing. Messing around w/ making fire thaw faster.
nemo
parents:
8560
diff
changeset
|
1290 |
dec(Gear^.Hedgehog^.Effects[heFrozen]) |
4d9d8287e601
Trying to improve rendering, sliding and thawing. Messing around w/ making fire thaw faster.
nemo
parents:
8560
diff
changeset
|
1291 |
end; |
8655
9fa380a18a65
At multiple requests, change ice to be turn based. This is a more modest adjustment of existing code, that can be fairly easily flagged or reverted if desired. It also allows scripts to extend freezing, and preserves fire melting.
nemo
parents:
8633
diff
changeset
|
1292 |
*) |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
1293 |
if (GameTicks mod 10 = 0) and (Gear^.Hedgehog^.Effects[heFrozen] > 0) and (Gear^.Hedgehog^.Effects[heFrozen] < 256) then |
8655
9fa380a18a65
At multiple requests, change ice to be turn based. This is a more modest adjustment of existing code, that can be fairly easily flagged or reverted if desired. It also allows scripts to extend freezing, and preserves fire melting.
nemo
parents:
8633
diff
changeset
|
1294 |
dec(Gear^.Hedgehog^.Effects[heFrozen]); |
6581 | 1295 |
if (Gear^.State and gstHHDriven) = 0 then |
1296 |
doStepHedgehogFree(Gear) |
|
1297 |
else |
|
1298 |
begin |
|
1299 |
with Gear^.Hedgehog^ do |
|
1300 |
if Team^.hasGone then |
|
1301 |
TeamGoneEffect(Team^) |
|
1302 |
else |
|
1303 |
doStepHedgehogDriven(Gear) |
|
1304 |
end; |
|
1305 |
end; |
|
1306 |
||
1307 |
end. |