author | sheepluva |
Sun, 15 May 2016 13:18:34 +0200 | |
changeset 11826 | d8844d4c67de |
parent 11770 | 10860d4bca22 |
child 11827 | 4600dcb9db4f |
permissions | -rw-r--r-- |
6581 | 1 |
(* |
2 |
* Hedgewars, a free turn based strategy game |
|
11046 | 3 |
* Copyright (c) 2004-2015 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 |
|
10108
c68cf030eded
update FSF address. note: two sdl include files (by Sam Lantinga) still have the old FSF address in their copyright - but I ain't gonna touch their copyright headers
sheepluva
parents:
10105
diff
changeset
|
16 |
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
6581 | 17 |
*) |
18 |
||
19 |
{$INCLUDE "options.inc"} |
|
20 |
||
21 |
unit uGearsHedgehog; |
|
22 |
interface |
|
10015 | 23 |
uses uTypes, uGearsHandlersMess; |
6581 | 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, |
9285 | 36 |
uCommands, uLocale, uUtils, uStats, uIO, uScript, |
37 |
uGearsList, uCollisions, uRandom, uStore, uTeams, |
|
9670
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset
|
38 |
uGearsUtils, uVisualGearsList, uChat; |
6581 | 39 |
|
7028 | 40 |
var GHStepTicks: LongWord = 0; |
41 |
||
9670
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset
|
42 |
procedure AFKSkip; |
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset
|
43 |
var |
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset
|
44 |
t: byte; |
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset
|
45 |
begin |
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset
|
46 |
t:= 0; |
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset
|
47 |
while (TeamsArray[t] <> CurrentTeam) do inc(t); |
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset
|
48 |
|
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset
|
49 |
SendHogSpeech(#1 + char(t) + 'AFK'); |
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset
|
50 |
|
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset
|
51 |
ParseCommand('/skip', true) |
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset
|
52 |
end; |
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset
|
53 |
|
6581 | 54 |
// Shouldn't more of this ammo switching stuff be moved to uAmmos ? |
55 |
function ChangeAmmo(HHGear: PGear): boolean; |
|
56 |
var slot, i: Longword; |
|
57 |
ammoidx: LongInt; |
|
7754 | 58 |
prevAmmo: TAmmoType; |
6581 | 59 |
begin |
60 |
ChangeAmmo:= false; |
|
61 |
slot:= HHGear^.MsgParam; |
|
62 |
||
63 |
with HHGear^.Hedgehog^ do |
|
64 |
begin |
|
65 |
HHGear^.Message:= HHGear^.Message and (not gmSlot); |
|
7754 | 66 |
prevAmmo:= CurAmmoType; |
6581 | 67 |
ammoidx:= 0; |
9732
a13afa6c5d21
don't abort changeammo on attacking/attacked in infattack mode, keep scrolling through slot after setweap even if a multishoot was aborted triggering gstattacked, to ensure proper ammo gets set for next turn
nemo
parents:
9731
diff
changeset
|
68 |
if (((HHGear^.State and (gstAttacking or gstAttacked)) <> 0) and (GameFlags and gfInfAttack = 0)) |
6581 | 69 |
or ((HHGear^.State and gstHHDriven) = 0) then |
70 |
exit; |
|
71 |
ChangeAmmo:= true; |
|
72 |
||
73 |
while (ammoidx < cMaxSlotAmmoIndex) and (Ammo^[slot, ammoidx].AmmoType <> CurAmmoType) do |
|
74 |
inc(ammoidx); |
|
75 |
||
8553
a8e1cff496d8
Allow switching away from any weapon when during multishoot.
nemo
parents:
8494
diff
changeset
|
76 |
if (MultiShootAttacks > 0) then |
a8e1cff496d8
Allow switching away from any weapon when during multishoot.
nemo
parents:
8494
diff
changeset
|
77 |
begin |
a8e1cff496d8
Allow switching away from any weapon when during multishoot.
nemo
parents:
8494
diff
changeset
|
78 |
if (CurAmmoType = amSniperRifle) and ((GameFlags and gfArtillery) = 0) then |
a8e1cff496d8
Allow switching away from any weapon when during multishoot.
nemo
parents:
8494
diff
changeset
|
79 |
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
|
80 |
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
|
81 |
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
|
82 |
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
|
83 |
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
|
84 |
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
|
85 |
else OnUsedAmmo(HHGear^.Hedgehog^) |
8553
a8e1cff496d8
Allow switching away from any weapon when during multishoot.
nemo
parents:
8494
diff
changeset
|
86 |
end; |
6581 | 87 |
|
88 |
MultiShootAttacks:= 0; |
|
89 |
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
|
90 |
|
6581 | 91 |
if Ammoz[CurAmmoType].Slot = slot then |
92 |
begin |
|
93 |
i:= 0; |
|
94 |
repeat |
|
95 |
inc(ammoidx); |
|
96 |
if (ammoidx > cMaxSlotAmmoIndex) then |
|
97 |
begin |
|
98 |
inc(i); |
|
99 |
CurAmmoType:= amNothing; |
|
100 |
ammoidx:= -1; |
|
101 |
//TryDo(i < 2, 'Engine bug: no ammo in current slot', true) |
|
102 |
end; |
|
103 |
until (i = 1) or ((Ammo^[slot, ammoidx].Count > 0) |
|
104 |
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
|
105 |
|
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
106 |
end |
6581 | 107 |
else |
108 |
begin |
|
109 |
i:= 0; |
|
110 |
// check whether there is ammo in slot |
|
111 |
while (i <= cMaxSlotAmmoIndex) and ((Ammo^[slot, i].Count = 0) |
|
112 |
or (Team^.Clan^.TurnNumber <= Ammoz[Ammo^[slot, i].AmmoType].SkipTurns)) |
|
113 |
do inc(i); |
|
114 |
||
115 |
if i <= cMaxSlotAmmoIndex then |
|
116 |
ammoidx:= i |
|
117 |
else ammoidx:= -1 |
|
118 |
end; |
|
119 |
if ammoidx >= 0 then |
|
120 |
CurAmmoType:= Ammo^[slot, ammoidx].AmmoType; |
|
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
|
121 |
// Try again in the next slot |
10015 | 122 |
if (CurAmmoType = prevAmmo) and (slot < cMaxSlotIndex) 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
|
123 |
begin |
9664
1e528c58e41d
ok. this should avoid calling switch inappropriately. also, add skip to trophyrace and add the per-team achievement reporting.
nemo
parents:
9579
diff
changeset
|
124 |
inc(slot); |
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
|
125 |
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
|
126 |
ChangeAmmo(HHGear) |
7754 | 127 |
end |
6581 | 128 |
end |
129 |
end; |
|
130 |
||
131 |
procedure HHSetWeapon(HHGear: PGear); |
|
132 |
var t: LongInt; |
|
133 |
weap: TAmmoType; |
|
134 |
Hedgehog: PHedgehog; |
|
135 |
s: boolean; |
|
9732
a13afa6c5d21
don't abort changeammo on attacking/attacked in infattack mode, keep scrolling through slot after setweap even if a multishoot was aborted triggering gstattacked, to ensure proper ammo gets set for next turn
nemo
parents:
9731
diff
changeset
|
136 |
prevState, newState: LongWord; |
6581 | 137 |
begin |
138 |
s:= false; |
|
139 |
||
140 |
weap:= TAmmoType(HHGear^.MsgParam); |
|
141 |
Hedgehog:= HHGear^.Hedgehog; |
|
142 |
||
143 |
if Hedgehog^.Team^.Clan^.TurnNumber <= Ammoz[weap].SkipTurns then |
|
144 |
exit; // weapon is not activated yet |
|
145 |
||
146 |
HHGear^.MsgParam:= Ammoz[weap].Slot; |
|
147 |
||
148 |
t:= cMaxSlotAmmoIndex; |
|
149 |
||
150 |
HHGear^.Message:= HHGear^.Message and (not gmWeapon); |
|
151 |
||
9732
a13afa6c5d21
don't abort changeammo on attacking/attacked in infattack mode, keep scrolling through slot after setweap even if a multishoot was aborted triggering gstattacked, to ensure proper ammo gets set for next turn
nemo
parents:
9731
diff
changeset
|
152 |
prevState:= HHGear^.State; |
a13afa6c5d21
don't abort changeammo on attacking/attacked in infattack mode, keep scrolling through slot after setweap even if a multishoot was aborted triggering gstattacked, to ensure proper ammo gets set for next turn
nemo
parents:
9731
diff
changeset
|
153 |
newState:= prevState; |
6581 | 154 |
with Hedgehog^ do |
155 |
while (CurAmmoType <> weap) and (t >= 0) do |
|
156 |
begin |
|
157 |
s:= ChangeAmmo(HHGear); |
|
9732
a13afa6c5d21
don't abort changeammo on attacking/attacked in infattack mode, keep scrolling through slot after setweap even if a multishoot was aborted triggering gstattacked, to ensure proper ammo gets set for next turn
nemo
parents:
9731
diff
changeset
|
158 |
if HHGear^.State <> prevState then // so we can keep gstAttacked out of consideration when looping |
a13afa6c5d21
don't abort changeammo on attacking/attacked in infattack mode, keep scrolling through slot after setweap even if a multishoot was aborted triggering gstattacked, to ensure proper ammo gets set for next turn
nemo
parents:
9731
diff
changeset
|
159 |
newState:= HHGear^.State; |
a13afa6c5d21
don't abort changeammo on attacking/attacked in infattack mode, keep scrolling through slot after setweap even if a multishoot was aborted triggering gstattacked, to ensure proper ammo gets set for next turn
nemo
parents:
9731
diff
changeset
|
160 |
HHGear^.State:= prevState; |
6581 | 161 |
dec(t) |
162 |
end; |
|
9732
a13afa6c5d21
don't abort changeammo on attacking/attacked in infattack mode, keep scrolling through slot after setweap even if a multishoot was aborted triggering gstattacked, to ensure proper ammo gets set for next turn
nemo
parents:
9731
diff
changeset
|
163 |
HHGear^.State:= newState; |
6581 | 164 |
|
165 |
if s then |
|
166 |
ApplyAmmoChanges(HHGear^.Hedgehog^) |
|
167 |
end; |
|
168 |
||
169 |
procedure HHSetTimer(Gear: PGear); |
|
170 |
var CurWeapon: PAmmo; |
|
171 |
color: LongWord; |
|
172 |
begin |
|
173 |
Gear^.Message:= Gear^.Message and (not gmTimer); |
|
6924 | 174 |
CurWeapon:= GetCurAmmoEntry(Gear^.Hedgehog^); |
6581 | 175 |
with Gear^.Hedgehog^ do |
176 |
if ((Gear^.Message and gmPrecise) <> 0) and ((CurWeapon^.Propz and ammoprop_SetBounce) <> 0) then |
|
177 |
begin |
|
178 |
color:= Gear^.Hedgehog^.Team^.Clan^.Color; |
|
179 |
case Gear^.MsgParam of |
|
180 |
1: begin |
|
10116
dd27562b6f21
rolling back my PChar stuff, because unC0Rr improves string handling pas2c instead <3
sheepluva
parents:
10108
diff
changeset
|
181 |
AddCaption(FormatA(trmsg[sidBounce], trmsg[sidBounce1]), color, capgrpAmmostate); |
6581 | 182 |
CurWeapon^.Bounciness:= 350; |
183 |
end; |
|
184 |
2: begin |
|
10116
dd27562b6f21
rolling back my PChar stuff, because unC0Rr improves string handling pas2c instead <3
sheepluva
parents:
10108
diff
changeset
|
185 |
AddCaption(FormatA(trmsg[sidBounce], trmsg[sidBounce2]), color, capgrpAmmostate); |
6581 | 186 |
CurWeapon^.Bounciness:= 700; |
187 |
end; |
|
188 |
3: begin |
|
10116
dd27562b6f21
rolling back my PChar stuff, because unC0Rr improves string handling pas2c instead <3
sheepluva
parents:
10108
diff
changeset
|
189 |
AddCaption(FormatA(trmsg[sidBounce], trmsg[sidBounce3]), color, capgrpAmmostate); |
6581 | 190 |
CurWeapon^.Bounciness:= 1000; |
191 |
end; |
|
192 |
4: begin |
|
10116
dd27562b6f21
rolling back my PChar stuff, because unC0Rr improves string handling pas2c instead <3
sheepluva
parents:
10108
diff
changeset
|
193 |
AddCaption(FormatA(trmsg[sidBounce], trmsg[sidBounce4]), color, capgrpAmmostate); |
6581 | 194 |
CurWeapon^.Bounciness:= 2000; |
195 |
end; |
|
196 |
5: begin |
|
10116
dd27562b6f21
rolling back my PChar stuff, because unC0Rr improves string handling pas2c instead <3
sheepluva
parents:
10108
diff
changeset
|
197 |
AddCaption(FormatA(trmsg[sidBounce], trmsg[sidBounce5]), color, capgrpAmmostate); |
6581 | 198 |
CurWeapon^.Bounciness:= 4000; |
199 |
end |
|
200 |
end |
|
201 |
end |
|
202 |
else if (CurWeapon^.Propz and ammoprop_Timerable) <> 0 then |
|
203 |
begin |
|
204 |
CurWeapon^.Timer:= 1000 * Gear^.MsgParam; |
|
205 |
with CurrentTeam^ do |
|
206 |
ApplyAmmoChanges(Hedgehogs[CurrHedgehog]); |
|
207 |
end; |
|
208 |
end; |
|
209 |
||
210 |
||
211 |
procedure Attack(Gear: PGear); |
|
212 |
var xx, yy, newDx, newDy, lx, ly: hwFloat; |
|
213 |
speech: PVisualGear; |
|
214 |
newGear: PGear; |
|
215 |
CurWeapon: PAmmo; |
|
10970
7341e0c3f966
LuaAPI: fix OnHogAttack the incorrect AmmoType (amNothing) under certain conditions. Thanks for CheezeMonkey for reporting this
sheepluva
parents:
10942
diff
changeset
|
216 |
usedAmmoType: TAmmoType; |
6581 | 217 |
altUse: boolean; |
218 |
elastic: hwFloat; |
|
219 |
begin |
|
220 |
newGear:= nil; |
|
221 |
bShowFinger:= false; |
|
6924 | 222 |
CurWeapon:= GetCurAmmoEntry(Gear^.Hedgehog^); |
6581 | 223 |
with Gear^, |
224 |
Gear^.Hedgehog^ do |
|
225 |
begin |
|
10970
7341e0c3f966
LuaAPI: fix OnHogAttack the incorrect AmmoType (amNothing) under certain conditions. Thanks for CheezeMonkey for reporting this
sheepluva
parents:
10942
diff
changeset
|
226 |
usedAmmoType:= CurAmmoType; |
10818
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
227 |
if ((State and gstHHDriven) <> 0) and ((State and (gstAttacked or gstChooseTarget)) = 0) and (((State and gstMoving) = 0) |
6581 | 228 |
or (Power > 0) |
229 |
or (CurAmmoType = amTeleport) |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
230 |
or |
6581 | 231 |
// Allow attacks while moving on ammo with AltAttack |
232 |
((CurAmmoGear <> nil) and ((Ammoz[CurAmmoGear^.AmmoType].Ammo.Propz and ammoprop_AltAttack) <> 0)) |
|
233 |
or ((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_AttackInMove) <> 0)) |
|
234 |
and ((TargetPoint.X <> NoPointX) or ((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_NeedTarget) = 0)) then |
|
235 |
begin |
|
236 |
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
|
237 |
if (Power = cMaxPower) or ((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_Power) = 0) then |
6581 | 238 |
Message:= Message and (not gmAttack) |
239 |
else |
|
240 |
begin |
|
241 |
if Power = 0 then |
|
242 |
begin |
|
243 |
AttackBar:= CurrentTeam^.AttackBar; |
|
244 |
PlaySound(sndThrowPowerUp) |
|
245 |
end; |
|
246 |
inc(Power) |
|
247 |
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
|
248 |
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
|
249 |
exit; |
6581 | 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
|
251 |
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
|
252 |
begin |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
253 |
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
|
254 |
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
|
255 |
end; |
6581 | 256 |
|
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
257 |
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
|
258 |
yy:= -AngleCos(Angle); |
6581 | 259 |
|
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
260 |
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
|
261 |
ly:= Y + int2hwfloat(round(GetLaunchY(CurAmmoType, Angle))); |
6581 | 262 |
|
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
263 |
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
|
264 |
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
|
265 |
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
|
266 |
AddVoice(Ammoz[CurAmmoType].Ammo.AttackVoice, CurrentTeam^.voicepack); |
6581 | 267 |
|
268 |
// 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
|
269 |
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
|
270 |
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
|
271 |
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
|
272 |
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
|
273 |
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
|
274 |
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
|
275 |
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
|
276 |
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
|
277 |
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
|
278 |
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
|
279 |
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
|
280 |
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
|
281 |
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
|
282 |
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
|
283 |
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
|
284 |
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
|
285 |
end |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
286 |
else |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
287 |
begin |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
288 |
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
|
289 |
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
|
290 |
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
|
291 |
end; |
6581 | 292 |
|
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
293 |
case CurAmmoType of |
6581 | 294 |
amGrenade: newGear:= AddGear(hwRound(lx), hwRound(ly), gtGrenade, 0, newDx, newDy, CurWeapon^.Timer); |
10789
acbf69e2e5cf
experiment with air mines. thought they could make shoppa... interesting. ToDo: Allow mines to give up, tweak distances, real graphics, toggle for whether they can acquire a new target while they haven't given up.
nemo
parents:
10714
diff
changeset
|
295 |
amAirMine: newGear:= AddGear(hwRound(lx), hwRound(ly), gtAirMine, 0, newDx, newDy, 0); |
6581 | 296 |
amMolotov: newGear:= AddGear(hwRound(lx), hwRound(ly), gtMolotov, 0, newDx, newDy, 0); |
297 |
amClusterBomb: newGear:= AddGear(hwRound(lx), hwRound(ly), gtClusterBomb, 0, newDx, newDy, CurWeapon^.Timer); |
|
298 |
amGasBomb: newGear:= AddGear(hwRound(lx), hwRound(ly), gtGasBomb, 0, newDx, newDy, CurWeapon^.Timer); |
|
299 |
amBazooka: newGear:= AddGear(hwRound(lx), hwRound(ly), gtShell, 0, newDx, newDy, 0); |
|
300 |
amSnowball: newGear:= AddGear(hwRound(lx), hwRound(ly), gtSnowball, 0, newDx, newDy, 0); |
|
301 |
amBee: newGear:= AddGear(hwRound(lx), hwRound(ly), gtBee, 0, newDx, newDy, 0); |
|
302 |
amShotgun: begin |
|
303 |
PlaySound(sndShotgunReload); |
|
304 |
newGear:= AddGear(hwRound(lx), hwRound(ly), gtShotgunShot, 0, xx * _0_5, yy * _0_5, 0); |
|
305 |
end; |
|
306 |
amPickHammer: newGear:= AddGear(hwRound(lx), hwRound(ly) + cHHRadius, gtPickHammer, 0, _0, _0, 0); |
|
307 |
amSkip: ParseCommand('/skip', true); |
|
308 |
amRope: newGear:= AddGear(hwRound(lx), hwRound(ly), gtRope, 0, xx, yy, 0); |
|
10942
5d7dd938dedc
This probably fixes bug #839 - mine time was hardcoded to 3000 in Attack, instead of using the "0 as undefined" input that other places were using. When re653e96b0ec3 started paying attention to the input parameter, this previously ignored value became a problem.
nemo
parents:
10895
diff
changeset
|
309 |
amMine: newGear:= AddGear(hwRound(lx) + hwSign(dX) * 7, hwRound(ly), gtMine, gstWait, SignAs(_0_02, dX), _0, 0); |
6581 | 310 |
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
|
311 |
amKnife: begin |
7754 | 312 |
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
|
313 |
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
|
314 |
newGear^.Radius:= 4 // temporarily shrink so it doesn't instantly embed in the ground |
7754 | 315 |
end; |
6581 | 316 |
amDEagle: newGear:= AddGear(hwRound(lx + xx * cHHRadius), hwRound(ly + yy * cHHRadius), gtDEagleShot, 0, xx * _0_5, yy * _0_5, 0); |
317 |
amSineGun: newGear:= AddGear(hwRound(lx + xx * cHHRadius), hwRound(ly + yy * cHHRadius), gtSineGunShot, 0, xx * _0_5, yy * _0_5, 0); |
|
318 |
amPortalGun: begin |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
319 |
newGear:= AddGear(hwRound(lx + xx * cHHRadius), hwRound(ly + yy * cHHRadius), gtPortal, 0, xx * _0_6, yy * _0_6, |
6581 | 320 |
// set selected color |
321 |
CurWeapon^.Pos); |
|
322 |
end; |
|
323 |
amSniperRifle: begin |
|
324 |
PlaySound(sndSniperReload); |
|
325 |
newGear:= AddGear(hwRound(lx + xx * cHHRadius), hwRound(ly + yy * cHHRadius), gtSniperRifleShot, 0, xx * _0_5, yy * _0_5, 0); |
|
326 |
end; |
|
327 |
amDynamite: newGear:= AddGear(hwRound(lx) + hwSign(dX) * 7, hwRound(ly), gtDynamite, 0, SignAs(_0_03, dX), _0, 5000); |
|
328 |
amFirePunch: newGear:= AddGear(hwRound(lx) + hwSign(dX) * 10, hwRound(ly), gtFirePunch, 0, xx, _0, 0); |
|
329 |
amWhip: begin |
|
330 |
newGear:= AddGear(hwRound(lx) + hwSign(dX) * 10, hwRound(ly), gtWhip, 0, SignAs(_1, dX), - _0_8, 0); |
|
331 |
PlaySound(sndWhipCrack) |
|
332 |
end; |
|
333 |
amHammer: begin |
|
334 |
newGear:= AddGear(hwRound(lx) + hwSign(dX) * 10, hwRound(ly), gtHammer, 0, SignAs(_1, dX), - _0_8, 0); |
|
335 |
PlaySound(sndWhack) |
|
336 |
end; |
|
337 |
amBaseballBat: begin |
|
338 |
newGear:= AddGear(hwRound(lx) + hwSign(dX) * 10, hwRound(ly), gtShover, gsttmpFlag, xx * _0_5, yy * _0_5, 0); |
|
339 |
PlaySound(sndBaseballBat) // TODO: Only play if something is hit? |
|
340 |
end; |
|
341 |
amParachute: begin |
|
342 |
newGear:= AddGear(hwRound(lx), hwRound(ly), gtParachute, 0, _0, _0, 0); |
|
343 |
PlaySound(sndParachute) |
|
344 |
end; |
|
345 |
// we save CurWeapon^.Pos (in this case: cursor direction) by using it as (otherwise irrelevant) X value of the new gear. |
|
346 |
amAirAttack: newGear:= AddGear(CurWeapon^.Pos, 0, gtAirAttack, 0, _0, _0, 0); |
|
347 |
amMineStrike: newGear:= AddGear(CurWeapon^.Pos, 0, gtAirAttack, 1, _0, _0, 0); |
|
348 |
amDrillStrike: newGear:= AddGear(CurWeapon^.Pos, 0, gtAirAttack, 3, _0, _0, CurWeapon^.Timer); |
|
349 |
amNapalm: newGear:= AddGear(CurWeapon^.Pos, 0, gtAirAttack, 2, _0, _0, 0); |
|
350 |
amBlowTorch: newGear:= AddGear(hwRound(lx), hwRound(ly), gtBlowTorch, 0, SignAs(_0_5, dX), _0, 0); |
|
351 |
amGirder: newGear:= AddGear(0, 0, gtGirder, CurWeapon^.Pos, _0, _0, 0); |
|
9768
08799c901a42
Add rubber utility. Graphics are still incomplete. Also flag snow/ice in theme config.
nemo
parents:
9732
diff
changeset
|
352 |
amRubber: begin |
08799c901a42
Add rubber utility. Graphics are still incomplete. Also flag snow/ice in theme config.
nemo
parents:
9732
diff
changeset
|
353 |
newGear:= AddGear(0, 0, gtGirder, CurWeapon^.Pos, _0, _0, 0); |
08799c901a42
Add rubber utility. Graphics are still incomplete. Also flag snow/ice in theme config.
nemo
parents:
9732
diff
changeset
|
354 |
newGear^.AmmoType:= amRubber |
08799c901a42
Add rubber utility. Graphics are still incomplete. Also flag snow/ice in theme config.
nemo
parents:
9732
diff
changeset
|
355 |
end; |
6581 | 356 |
amTeleport: newGear:= AddGear(CurWeapon^.Pos, 0, gtTeleport, 0, _0, _0, 0); |
357 |
amSwitch: newGear:= AddGear(hwRound(lx), hwRound(ly), gtSwitcher, 0, _0, _0, 0); |
|
358 |
amMortar: begin |
|
359 |
playSound(sndMortar); |
|
360 |
newGear:= AddGear(hwRound(lx), hwRound(ly), gtMortar, 0, xx*cMaxPower/cPowerDivisor, yy*cMaxPower/cPowerDivisor, 0); |
|
361 |
end; |
|
362 |
amRCPlane: begin |
|
363 |
newGear:= AddGear(hwRound(lx), hwRound(ly), gtRCPlane, 0, xx * cMaxPower / cPowerDivisor / 4, yy * cMaxPower / cPowerDivisor / 4, 0); |
|
7053 | 364 |
newGear^.SoundChannel:= LoopSound(sndRCPlane) |
6581 | 365 |
end; |
366 |
amKamikaze: newGear:= AddGear(hwRound(lx), hwRound(ly), gtKamikaze, 0, xx * _0_5, yy * _0_5, 0); |
|
7832 | 367 |
amCake: newGear:= AddGear(hwRound(lx) + hwSign(dX) * 3, hwRound(ly), gtCake, 0, SignAs(cLittle, xx), _0, 0); |
6581 | 368 |
amSeduction: newGear:= AddGear(hwRound(lx), hwRound(ly), gtSeduction, 0, _0, _0, 0); |
369 |
amWatermelon: newGear:= AddGear(hwRound(lx), hwRound(ly), gtWatermelon, 0, newDx, newDy, CurWeapon^.Timer); |
|
370 |
amHellishBomb: newGear:= AddGear(hwRound(lx), hwRound(ly), gtHellishBomb, 0, newDx, newDy, 0); |
|
371 |
amDrill: newGear:= AddGear(hwRound(lx), hwRound(ly), gtDrill, 0, newDx, newDy, 0); |
|
372 |
amBallgun: newGear:= AddGear(hwRound(X), hwRound(Y), gtBallgun, 0, xx * _0_5, yy * _0_5, 0); |
|
373 |
amJetpack: newGear:= AddGear(hwRound(lx), hwRound(ly), gtJetpack, 0, _0, _0, 0); |
|
374 |
amBirdy: begin |
|
375 |
PlaySound(sndWhistle); |
|
376 |
newGear:= AddGear(hwRound(lx), hwRound(ly) - 32, gtBirdy, 0, _0, _0, 0); |
|
377 |
end; |
|
378 |
amLowGravity: begin |
|
379 |
PlaySound(sndLowGravity); |
|
380 |
cGravity:= cMaxWindSpeed; |
|
381 |
cGravityf:= 0.00025 |
|
382 |
end; |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
383 |
amExtraDamage: begin |
6581 | 384 |
PlaySound(sndHellishImpact4); |
385 |
cDamageModifier:= _1_5 |
|
386 |
end; |
|
9685
7d925e82e572
Tweak trophyrace to work better w/ skip (probably, needs testing), drop Invulnerable in favour of effects - heInvulnerable is already in effects,
nemo
parents:
9675
diff
changeset
|
387 |
amInvulnerable: Effects[heInvulnerable]:= 1; |
6581 | 388 |
amExtraTime: begin |
11770
10860d4bca22
Add sound effects for: cleaver impact, air mine impact, using extra time
Wuzzy <almikes@aol.com>
parents:
11629
diff
changeset
|
389 |
PlaySound(sndExtraTime); |
6581 | 390 |
TurnTimeLeft:= TurnTimeLeft + 30000 |
391 |
end; |
|
392 |
amLaserSight: cLaserSighting:= true; |
|
393 |
amVampiric: begin |
|
7053 | 394 |
PlaySoundV(sndOw1, Team^.voicepack); |
6581 | 395 |
cVampiric:= true; |
396 |
end; |
|
397 |
amPiano: begin |
|
398 |
// Tuck the hedgehog away until the piano attack is completed |
|
399 |
Unplaced:= true; |
|
400 |
X:= _0; |
|
401 |
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
|
402 |
newGear:= AddGear(TargetPoint.X, -1024, gtPiano, 0, _0, _0, 0); |
6581 | 403 |
PauseMusic |
404 |
end; |
|
405 |
amFlamethrower: newGear:= AddGear(hwRound(X), hwRound(Y), gtFlamethrower, 0, xx * _0_5, yy * _0_5, 0); |
|
406 |
amLandGun: newGear:= AddGear(hwRound(X), hwRound(Y), gtLandGun, 0, xx * _0_5, yy * _0_5, 0); |
|
407 |
amResurrector: begin |
|
408 |
newGear:= AddGear(hwRound(lx), hwRound(ly), gtResurrector, 0, _0, _0, 0); |
|
409 |
newGear^.SoundChannel := LoopSound(sndResurrector); |
|
410 |
end; |
|
8161 | 411 |
//amStructure: newGear:= AddGear(hwRound(lx) + hwSign(dX) * 7, hwRound(ly), gtStructure, gstWait, SignAs(_0_02, dX), _0, 3000); |
9675
295636ec930a
cleanup of timer accidentally exposed prob w/ timebox
nemo
parents:
9672
diff
changeset
|
412 |
amTardis: newGear:= AddGear(hwRound(X), hwRound(Y), gtTardis, 0, _0, _0, 0); |
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
|
413 |
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
|
414 |
end; |
10015 | 415 |
if altUse and (newGear <> nil) and |
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
|
416 |
((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
|
417 |
begin |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
418 |
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
|
419 |
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
|
420 |
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
|
421 |
if (CurAmmoGear <> nil) and (CurAmmoGear^.AmmoType = amJetpack) and |
10354 | 422 |
(Gear^.Message and gmPrecise <> 0) and CheckCoordInWater(hwRound(X), hwRound(Y)) 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
|
423 |
newGear^.State:= newGear^.State or gstSubmersible; |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
424 |
|
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
425 |
case CurAmmoType of |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
426 |
amGrenade, amMolotov, |
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
427 |
amClusterBomb, amGasBomb, |
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
428 |
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
|
429 |
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
|
430 |
amMortar, amWatermelon, |
10789
acbf69e2e5cf
experiment with air mines. thought they could make shoppa... interesting. ToDo: Allow mines to give up, tweak distances, real graphics, toggle for whether they can acquire a new target while they haven't given up.
nemo
parents:
10714
diff
changeset
|
431 |
amHellishBomb, amDrill, |
acbf69e2e5cf
experiment with air mines. thought they could make shoppa... interesting. ToDo: Allow mines to give up, tweak distances, real graphics, toggle for whether they can acquire a new target while they haven't given up.
nemo
parents:
10714
diff
changeset
|
432 |
amAirMine: FollowGear:= newGear; |
6581 | 433 |
|
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
434 |
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
|
435 |
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
|
436 |
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
|
437 |
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
|
438 |
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
|
439 |
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
|
440 |
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
|
441 |
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
|
442 |
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
|
443 |
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
|
444 |
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
|
445 |
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
|
446 |
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
|
447 |
amTardis, amPiano, |
9776 | 448 |
amIceGun, amRubber: CurAmmoGear:= newGear; |
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
449 |
end; |
10789
acbf69e2e5cf
experiment with air mines. thought they could make shoppa... interesting. ToDo: Allow mines to give up, tweak distances, real graphics, toggle for whether they can acquire a new target while they haven't given up.
nemo
parents:
10714
diff
changeset
|
450 |
if CurAmmoType = amCake then FollowGear:= newGear; |
acbf69e2e5cf
experiment with air mines. thought they could make shoppa... interesting. ToDo: Allow mines to give up, tweak distances, real graphics, toggle for whether they can acquire a new target while they haven't given up.
nemo
parents:
10714
diff
changeset
|
451 |
if CurAmmoType = amAirMine then newGear^.Hedgehog:= nil; |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
452 |
|
10789
acbf69e2e5cf
experiment with air mines. thought they could make shoppa... interesting. ToDo: Allow mines to give up, tweak distances, real graphics, toggle for whether they can acquire a new target while they haven't given up.
nemo
parents:
10714
diff
changeset
|
453 |
if ((CurAmmoType = amMine) or (CurAmmoType = amSMine) or (CurAmmoType = amAirMine)) and (GameFlags and gfInfAttack <> 0) then |
11201 | 454 |
newGear^.FlightTime:= GameTicks + min(TurnTimeLeft,1000) |
6581 | 455 |
else if CurAmmoType = amDrill then |
456 |
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
|
457 |
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
|
458 |
begin |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
459 |
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
|
460 |
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
|
461 |
end; |
8744 | 462 |
if (newGear <> nil) and (newGear^.CollisionMask and lfCurrentHog <> 0) then newGear^.CollisionMask:= newGear^.CollisionMask and (not lfCurrentHog); |
6581 | 463 |
|
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
464 |
// 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
|
465 |
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
|
466 |
FollowGear:= nil; |
6581 | 467 |
|
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
468 |
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
|
469 |
begin |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
470 |
elastic:= int2hwfloat(CurWeapon^.Bounciness) / _1000; |
6581 | 471 |
|
472 |
if elastic < _1 then |
|
473 |
newGear^.Elasticity:= newGear^.Elasticity * elastic |
|
474 |
else if elastic > _1 then |
|
475 |
newGear^.Elasticity:= _1 - ((_1-newGear^.Elasticity) / elastic); |
|
8330 | 476 |
(* Experimented with friction modifier. Didn't seem helpful |
6581 | 477 |
fric:= int2hwfloat(CurWeapon^.Bounciness) / _250; |
478 |
if fric < _1 then newGear^.Friction:= newGear^.Friction * fric |
|
479 |
else if fric > _1 then newGear^.Friction:= _1 - ((_1-newGear^.Friction) / fric)*) |
|
480 |
end; |
|
481 |
||
482 |
||
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
483 |
uStats.AmmoUsed(CurAmmoType); |
6581 | 484 |
|
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
485 |
if not (SpeechText = '') then |
6581 | 486 |
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
|
487 |
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
|
488 |
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
|
489 |
begin |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
490 |
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
|
491 |
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
|
492 |
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
|
493 |
end; |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
494 |
SpeechText:= '' |
6581 | 495 |
end; |
496 |
||
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
497 |
Power:= 0; |
8833 | 498 |
if (CurAmmoGear <> nil) and ((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_AltUse) = 0){check for dropping ammo from rope} 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
|
499 |
begin |
8833 | 500 |
if CurAmmoType in [amRope,amResurrector] then |
501 |
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
|
502 |
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
|
503 |
end |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
504 |
else |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
505 |
begin |
8833 | 506 |
if (not CurrentTeam^.ExtDriven) and ((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_Power) <> 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
|
507 |
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
|
508 |
AfterAttack; |
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset
|
509 |
end |
6581 | 510 |
end |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
511 |
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
|
512 |
Message:= Message and (not gmAttack); |
10669
4c78eafe76ac
Issue 755: Lua API: Add ammo type parameter for onHogAttack
sheepluva
parents:
10579
diff
changeset
|
513 |
|
10970
7341e0c3f966
LuaAPI: fix OnHogAttack the incorrect AmmoType (amNothing) under certain conditions. Thanks for CheezeMonkey for reporting this
sheepluva
parents:
10942
diff
changeset
|
514 |
ScriptCall('onHogAttack', ord(usedAmmoType)); |
10669
4c78eafe76ac
Issue 755: Lua API: Add ammo type parameter for onHogAttack
sheepluva
parents:
10579
diff
changeset
|
515 |
end; // of with Gear^, Gear^.Hedgehog^ do |
4c78eafe76ac
Issue 755: Lua API: Add ammo type parameter for onHogAttack
sheepluva
parents:
10579
diff
changeset
|
516 |
|
6581 | 517 |
TargetPoint.X := NoPointX; |
518 |
end; |
|
519 |
||
520 |
procedure AfterAttack; |
|
10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10123
diff
changeset
|
521 |
var s: ansistring; |
6581 | 522 |
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
|
523 |
HHGear: PGear; |
6581 | 524 |
begin |
7459
8511a3f899d3
Allow AfterAttack to proceed even if the Hedgehog is dead. They could be resurrected after all.
nemo
parents:
7426
diff
changeset
|
525 |
with CurrentHedgehog^ do |
6581 | 526 |
begin |
7459
8511a3f899d3
Allow AfterAttack to proceed even if the Hedgehog is dead. They could be resurrected after all.
nemo
parents:
7426
diff
changeset
|
527 |
HHGear:= Gear; |
6581 | 528 |
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
|
529 |
if HHGear <> nil then HHGear^.State:= HHGear^.State and (not gstAttacking); |
6581 | 530 |
if (Ammoz[a].Ammo.Propz and ammoprop_Effect) = 0 then |
531 |
begin |
|
532 |
Inc(MultiShootAttacks); |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
533 |
|
6581 | 534 |
if (Ammoz[a].Ammo.NumPerTurn >= MultiShootAttacks) then |
535 |
begin |
|
10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10123
diff
changeset
|
536 |
s:= ansistring(inttostr(Ammoz[a].Ammo.NumPerTurn - MultiShootAttacks + 1)); |
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10123
diff
changeset
|
537 |
AddCaption(formatA(trmsg[sidRemaining], s), cWhiteColor, capgrpAmmostate); |
6581 | 538 |
end; |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
539 |
|
6581 | 540 |
if (Ammoz[a].Ammo.NumPerTurn >= MultiShootAttacks) |
541 |
or ((GameFlags and gfMultiWeapon) <> 0) then |
|
542 |
begin |
|
543 |
isInMultiShoot:= true |
|
544 |
end |
|
545 |
else |
|
546 |
begin |
|
547 |
OnUsedAmmo(CurrentHedgehog^); |
|
548 |
if ((Ammoz[a].Ammo.Propz and ammoprop_NoRoundEnd) = 0) and (((GameFlags and gfInfAttack) = 0) or PlacingHogs) then |
|
549 |
begin |
|
550 |
if TagTurnTimeLeft = 0 then |
|
551 |
TagTurnTimeLeft:= TurnTimeLeft; |
|
10354 | 552 |
if (CurAmmoGear <> nil) and (CurAmmoGear^.State and gstSubmersible <> 0) and CheckCoordInWater(hwRound(CurAmmoGear^.X), hwRound(CurAmmoGear^.Y)) 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
|
553 |
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
|
554 |
else TurnTimeLeft:=(Ammoz[a].TimeAfterTurn * cGetAwayTime) div 100; |
6581 | 555 |
end; |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
556 |
if ((Ammoz[a].Ammo.Propz and ammoprop_NoRoundEnd) = 0) and (HHGear <> nil) then |
7462 | 557 |
HHGear^.State:= HHGear^.State or gstAttacked; |
6581 | 558 |
if (Ammoz[a].Ammo.Propz and ammoprop_NoRoundEnd) <> 0 then |
559 |
ApplyAmmoChanges(CurrentHedgehog^) |
|
560 |
end; |
|
561 |
end |
|
562 |
else |
|
563 |
begin |
|
564 |
OnUsedAmmo(CurrentHedgehog^); |
|
565 |
ApplyAmmoChanges(CurrentHedgehog^); |
|
566 |
end; |
|
567 |
AttackBar:= 0 |
|
568 |
end |
|
569 |
end; |
|
570 |
||
571 |
//////////////////////////////////////////////////////////////////////////////// |
|
572 |
procedure doStepHedgehogDead(Gear: PGear); |
|
573 |
const frametime = 200; |
|
574 |
timertime = frametime * 6; |
|
11206 | 575 |
var grave: PGear; |
6581 | 576 |
begin |
577 |
if Gear^.Hedgehog^.Unplaced then |
|
578 |
exit; |
|
579 |
if Gear^.Timer > 1 then |
|
580 |
begin |
|
581 |
AllInactive:= false; |
|
582 |
dec(Gear^.Timer); |
|
583 |
if (Gear^.Timer mod frametime) = 0 then |
|
584 |
inc(Gear^.Pos) |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
585 |
end |
6581 | 586 |
else if Gear^.Timer = 1 then |
587 |
begin |
|
9064 | 588 |
Gear^.Hedgehog^.Effects[heFrozen]:= 0; |
6581 | 589 |
Gear^.State:= Gear^.State or gstNoDamage; |
11473
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11272
diff
changeset
|
590 |
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), Gear^.Boom, CurrentHedgehog, EXPLAutoSound); |
11206 | 591 |
grave:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtGrave, 0, _0, _0, 0); |
592 |
grave^.Hedgehog:= Gear^.Hedgehog; |
|
593 |
grave^.Pos:= Gear^.uid; |
|
594 |
||
6581 | 595 |
DeleteGear(Gear); |
596 |
SetAllToActive |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
597 |
end |
6581 | 598 |
else // Gear^.Timer = 0 |
599 |
begin |
|
600 |
AllInactive:= false; |
|
601 |
Gear^.Z:= cCurrHHZ; |
|
602 |
RemoveGearFromList(Gear); |
|
603 |
InsertGearToList(Gear); |
|
7053 | 604 |
PlaySoundV(sndByeBye, Gear^.Hedgehog^.Team^.voicepack); |
6581 | 605 |
Gear^.Pos:= 0; |
606 |
Gear^.Timer:= timertime |
|
607 |
end |
|
608 |
end; |
|
609 |
||
610 |
//////////////////////////////////////////////////////////////////////////////// |
|
611 |
procedure doStepHedgehogGone(Gear: PGear); |
|
612 |
const frametime = 65; |
|
613 |
timertime = frametime * 11; |
|
10178
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset
|
614 |
var i: LongInt; |
6581 | 615 |
begin |
616 |
if Gear^.Hedgehog^.Unplaced then |
|
617 |
exit; |
|
618 |
if Gear^.Timer > 1 then |
|
619 |
begin |
|
620 |
AllInactive:= false; |
|
621 |
dec(Gear^.Timer); |
|
622 |
if (Gear^.Timer mod frametime) = 0 then |
|
623 |
inc(Gear^.Pos) |
|
624 |
end |
|
625 |
else |
|
626 |
if Gear^.Timer = 1 then |
|
627 |
begin |
|
628 |
DeleteGear(Gear); |
|
629 |
SetAllToActive |
|
630 |
end |
|
631 |
else // Gear^.Timer = 0 |
|
632 |
begin |
|
633 |
AllInactive:= false; |
|
634 |
Gear^.Z:= cCurrHHZ; |
|
635 |
RemoveGearFromList(Gear); |
|
636 |
InsertGearToList(Gear); |
|
10178
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset
|
637 |
// only play sound for one alive hedgehog |
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset
|
638 |
with Gear^.Hedgehog^.Team^ do |
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset
|
639 |
for i:= 0 to cMaxHHIndex do |
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset
|
640 |
begin |
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset
|
641 |
if (Hedgehogs[i].Gear <> nil) then |
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset
|
642 |
begin |
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset
|
643 |
if (Hedgehogs[i].Gear = Gear) then |
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset
|
644 |
begin |
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset
|
645 |
PlaySoundV(sndByeBye, Gear^.Hedgehog^.Team^.voicepack); |
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset
|
646 |
PlaySound(sndWarp); |
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset
|
647 |
end; |
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset
|
648 |
break; |
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset
|
649 |
end; |
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset
|
650 |
end; |
6581 | 651 |
Gear^.Pos:= 0; |
652 |
Gear^.Timer:= timertime |
|
653 |
end |
|
654 |
end; |
|
655 |
||
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
|
656 |
procedure AddPickup(HH: THedgehog; ammo: TAmmoType; cnt, X, Y: LongWord); |
10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10123
diff
changeset
|
657 |
var s: ansistring; |
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
|
658 |
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
|
659 |
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
|
660 |
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
|
661 |
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
|
662 |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
663 |
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
|
664 |
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
|
665 |
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
|
666 |
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
|
667 |
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
|
668 |
if cnt <> 0 then |
10123 | 669 |
s:= trammo[Ammoz[ammo].NameId] + ansistring(' (+' + IntToStr(cnt) + ')') |
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
|
670 |
else |
10123 | 671 |
s:= trammo[Ammoz[ammo].NameId] + ansistring(' (+' + IntToStr(Ammoz[ammo].NumberInCase) + ')'); |
10116
dd27562b6f21
rolling back my PChar stuff, because unC0Rr improves string handling pas2c instead <3
sheepluva
parents:
10108
diff
changeset
|
672 |
AddCaption(s, HH.Team^.Clan^.Color, capgrpAmmoinfo); |
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
|
673 |
|
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
|
674 |
// 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
|
675 |
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
|
676 |
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
|
677 |
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
|
678 |
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
|
679 |
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
|
680 |
|
6581 | 681 |
//////////////////////////////////////////////////////////////////////////////// |
682 |
procedure PickUp(HH, Gear: PGear); |
|
683 |
var s: shortstring; |
|
7406
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset
|
684 |
i: LongInt; |
6581 | 685 |
vga: PVisualGear; |
7406
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset
|
686 |
ag, gi: PGear; |
6581 | 687 |
begin |
11629 | 688 |
if Gear^.State and gstFrozen <> 0 then exit; |
689 |
||
6581 | 690 |
Gear^.Message:= gmDestroy; |
691 |
if (Gear^.Pos and posCaseExplode) <> 0 then |
|
692 |
if (Gear^.Pos and posCasePoison) <> 0 then |
|
693 |
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 25, HH^.Hedgehog, EXPLAutoSound + EXPLPoisoned) |
|
694 |
else |
|
695 |
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 25, HH^.Hedgehog, EXPLAutoSound) |
|
696 |
else if (Gear^.Pos and posCasePoison) <> 0 then |
|
697 |
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 25, HH^.Hedgehog, EXPLAutoSound + EXPLPoisoned + EXPLNoDamage) |
|
698 |
else |
|
699 |
case Gear^.Pos of |
|
700 |
posCaseUtility, |
|
701 |
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
|
702 |
PlaySound(sndShotgunReload); |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
703 |
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
|
704 |
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
|
705 |
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
|
706 |
end |
6581 | 707 |
else |
708 |
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
|
709 |
// Add spawning here... |
7409 | 710 |
AddRandomness(GameTicks); |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
711 |
|
7406
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset
|
712 |
gi := GearsList; |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset
|
713 |
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
|
714 |
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
|
715 |
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
|
716 |
begin |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset
|
717 |
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
|
718 |
gi^.State:= gi^.State or gstTmpFlag; |
7406
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset
|
719 |
gi^.X:= int2hwFloat(GetRandom(rightX-leftX)+leftX); |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset
|
720 |
gi^.Y:= int2hwFloat(GetRandom(LAND_HEIGHT-topY)+topY); |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset
|
721 |
gi^.dX:= _90-(GetRandomf*_360); |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset
|
722 |
gi^.dY:= _90-(GetRandomf*_360) |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset
|
723 |
end; |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset
|
724 |
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
|
725 |
end; |
7598 | 726 |
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
|
727 |
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
|
728 |
ag^.Power:= Gear^.Power |
6581 | 729 |
end; |
730 |
end; |
|
731 |
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
|
732 |
PlaySound(sndShotgunReload); |
6581 | 733 |
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
|
734 |
HH^.Hedgehog^.Effects[hePoisoned] := 0; |
6581 | 735 |
str(Gear^.Health, s); |
736 |
s:= '+' + s; |
|
10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10123
diff
changeset
|
737 |
AddCaption(ansistring(s), HH^.Hedgehog^.Team^.Clan^.Color, capgrpAmmoinfo); |
6581 | 738 |
RenderHealth(HH^.Hedgehog^); |
739 |
RecountTeamHealth(HH^.Hedgehog^.Team); |
|
740 |
||
741 |
i:= 0; |
|
742 |
while i < Gear^.Health do |
|
743 |
begin |
|
744 |
vga:= AddVisualGear(hwRound(HH^.X), hwRound(HH^.Y), vgtStraightShot); |
|
745 |
if vga <> nil then |
|
746 |
with vga^ do |
|
747 |
begin |
|
748 |
Tint:= $00FF00FF; |
|
749 |
State:= ord(sprHealth) |
|
750 |
end; |
|
751 |
inc(i, 5); |
|
752 |
end; |
|
753 |
end; |
|
754 |
end |
|
755 |
end; |
|
756 |
||
757 |
procedure HedgehogStep(Gear: PGear); |
|
758 |
var PrevdX: LongInt; |
|
759 |
CurWeapon: PAmmo; |
|
10435
4c8fc3aa9432
allow hogs to repeatedly enter portals placed on the ground
nemo
parents:
10354
diff
changeset
|
760 |
portals: PGearArrayS; |
6581 | 761 |
begin |
6924 | 762 |
CurWeapon:= GetCurAmmoEntry(Gear^.Hedgehog^); |
6581 | 763 |
if ((Gear^.State and (gstAttacking or gstMoving)) = 0) then |
764 |
begin |
|
765 |
if isCursorVisible then |
|
766 |
with Gear^.Hedgehog^ do |
|
767 |
with CurWeapon^ do |
|
768 |
begin |
|
769 |
if (Gear^.Message and gmLeft ) <> 0 then |
|
770 |
Pos:= (Pos - 1 + Ammoz[AmmoType].PosCount) mod Ammoz[AmmoType].PosCount |
|
771 |
else |
|
772 |
if (Gear^.Message and gmRight ) <> 0 then |
|
773 |
Pos:= (Pos + 1) mod Ammoz[AmmoType].PosCount |
|
774 |
else |
|
775 |
exit; |
|
7028 | 776 |
GHStepTicks:= 200; |
6581 | 777 |
exit |
778 |
end; |
|
779 |
||
780 |
if ((Gear^.Message and gmAnimate) <> 0) then |
|
781 |
begin |
|
782 |
Gear^.Message:= 0; |
|
783 |
Gear^.State:= Gear^.State or gstAnimation; |
|
784 |
Gear^.Tag:= Gear^.MsgParam; |
|
785 |
Gear^.Timer:= 0; |
|
786 |
Gear^.Pos:= 0 |
|
787 |
end; |
|
788 |
||
789 |
if ((Gear^.Message and gmLJump ) <> 0) then |
|
790 |
begin |
|
791 |
Gear^.Message:= Gear^.Message and (not gmLJump); |
|
792 |
DeleteCI(Gear); |
|
793 |
if TestCollisionYwithGear(Gear, -1) = 0 then |
|
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
794 |
if TestCollisionXwithXYShift(Gear, _0, -2, hwSign(Gear^.dX)) = 0 then |
6581 | 795 |
Gear^.Y:= Gear^.Y - _2 |
796 |
else |
|
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
797 |
if TestCollisionXwithXYShift(Gear, _0, -1, hwSign(Gear^.dX)) = 0 then |
6581 | 798 |
Gear^.Y:= Gear^.Y - _1; |
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
799 |
if (TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) = 0) and |
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
800 |
(TestCollisionYwithGear(Gear, -1) = 0) then |
6581 | 801 |
begin |
802 |
Gear^.dY:= -_0_15; |
|
803 |
if not cArtillery then |
|
804 |
Gear^.dX:= SignAs(_0_15, Gear^.dX); |
|
805 |
Gear^.State:= Gear^.State or gstMoving or gstHHJumping; |
|
7053 | 806 |
PlaySoundV(sndJump1, Gear^.Hedgehog^.Team^.voicepack); |
6581 | 807 |
exit |
808 |
end; |
|
809 |
end; |
|
810 |
||
811 |
if ((Gear^.Message and gmHJump ) <> 0) then |
|
812 |
begin |
|
813 |
DeleteCI(Gear); |
|
814 |
Gear^.Message:= Gear^.Message and (not gmHJump); |
|
815 |
||
816 |
Gear^.dY:= -_0_2; |
|
817 |
SetLittle(Gear^.dX); |
|
818 |
Gear^.State:= Gear^.State or gstMoving or gstHHJumping; |
|
7053 | 819 |
PlaySoundV(sndJump3, Gear^.Hedgehog^.Team^.voicepack); |
6581 | 820 |
exit |
821 |
end; |
|
822 |
||
10435
4c8fc3aa9432
allow hogs to repeatedly enter portals placed on the ground
nemo
parents:
10354
diff
changeset
|
823 |
if (Gear^.Message and (gmLeft or gmRight) <> 0) and (Gear^.State and gstMoving = 0) then |
4c8fc3aa9432
allow hogs to repeatedly enter portals placed on the ground
nemo
parents:
10354
diff
changeset
|
824 |
begin |
4c8fc3aa9432
allow hogs to repeatedly enter portals placed on the ground
nemo
parents:
10354
diff
changeset
|
825 |
// slightly inefficient since it doesn't halt after one portal, maybe could add a param to GearsNear for number desired. |
4c8fc3aa9432
allow hogs to repeatedly enter portals placed on the ground
nemo
parents:
10354
diff
changeset
|
826 |
portals:= GearsNear(Gear^.X, Gear^.Y, gtPortal, 26); |
4c8fc3aa9432
allow hogs to repeatedly enter portals placed on the ground
nemo
parents:
10354
diff
changeset
|
827 |
if portals.size = 0 then Gear^.PortalCounter:= 0 |
4c8fc3aa9432
allow hogs to repeatedly enter portals placed on the ground
nemo
parents:
10354
diff
changeset
|
828 |
end; |
6581 | 829 |
PrevdX:= hwSign(Gear^.dX); |
830 |
if (Gear^.Message and gmLeft )<>0 then |
|
831 |
Gear^.dX:= -cLittle else |
|
832 |
if (Gear^.Message and gmRight )<>0 then |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
833 |
Gear^.dX:= cLittle |
7187
aff30d80bd7b
- Allow camera movement while current hedgehog is falling
unc0rr
parents:
7164
diff
changeset
|
834 |
else exit; |
6581 | 835 |
|
7187
aff30d80bd7b
- Allow camera movement while current hedgehog is falling
unc0rr
parents:
7164
diff
changeset
|
836 |
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
|
837 |
|
7028 | 838 |
GHStepTicks:= cHHStepTicks; |
6581 | 839 |
if PrevdX <> hwSign(Gear^.dX) then |
840 |
begin |
|
841 |
FollowGear:= Gear; |
|
842 |
exit |
|
843 |
end; |
|
844 |
DeleteCI(Gear); // must be after exit!! (see previous line) |
|
845 |
||
846 |
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
|
847 |
|
10714 | 848 |
if (not cArtillery or |
849 |
((CurAmmoGear <> nil) and (CurAmmoGear^.Kind = gtBlowTorch))) and |
|
850 |
((Gear^.Message and gmPrecise) = 0) then |
|
7719
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7671
diff
changeset
|
851 |
MakeHedgehogsStep(Gear); |
6581 | 852 |
|
8576
286ebfcb3d97
workaround for frequent AllHH active call in hedgehog step
nemo
parents:
8574
diff
changeset
|
853 |
SetAllHHToActive(false); |
9291
15f7bb217b66
Make add/delete consistent (this has bugged me for so long)
nemo
parents:
9285
diff
changeset
|
854 |
AddCI(Gear) |
6581 | 855 |
end |
856 |
end; |
|
857 |
||
858 |
procedure HedgehogChAngle(HHGear: PGear); |
|
859 |
var da: LongWord; |
|
860 |
begin |
|
861 |
with HHGear^.Hedgehog^ do |
|
10015 | 862 |
if (((CurAmmoType = amRope) or ((CurAmmoGear <> nil) and (CurAmmoGear^.AmmoType = amRope))) and |
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
|
863 |
((HHGear^.State and (gstMoving or gstHHJumping)) = gstMoving)) |
6581 | 864 |
or ((CurAmmoType = amPortalGun) and ((HHGear^.State and gstMoving) <> 0)) then |
865 |
da:= 2 |
|
866 |
else da:= 1; |
|
867 |
||
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
|
868 |
if ((HHGear^.Message and gmPrecise = 0) or ((CurAmmoGear <> nil) and (CurAmmoGear^.AmmoType = amJetpack))) or (GameTicks mod 5 = 1) then |
6581 | 869 |
if ((HHGear^.Message and gmUp) <> 0) and (HHGear^.Angle >= CurMinAngle + da) then |
870 |
dec(HHGear^.Angle, da) |
|
871 |
else |
|
872 |
if ((HHGear^.Message and gmDown) <> 0) and (HHGear^.Angle + da <= CurMaxAngle) then |
|
873 |
inc(HHGear^.Angle, da) |
|
874 |
end; |
|
875 |
||
876 |
||
877 |
//////////////////////////////////////////////////////////////////////////////// |
|
11517
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
878 |
procedure moveHedgehogOutOfWall(Gear: PGear); |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
879 |
var |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
880 |
hx: hwFloat; |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
881 |
colly, collxl, collxr: boolean; |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
882 |
begin |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
883 |
colly:= (TestCollisionYwithGear(Gear, 1) <> 0); |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
884 |
|
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
885 |
while colly do |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
886 |
begin |
11518
d44d2ab7ce4a
fix comment; revert unintentional commit of some testing png
sheepluva
parents:
11517
diff
changeset
|
887 |
// don't use TestCollisionXwithXYShift, because it checks for gears |
11517
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
888 |
// save real x-position |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
889 |
hx:= Gear^.X; |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
890 |
|
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
891 |
Gear^.X:= hx + _1; |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
892 |
collxl:= (TestCollisionX(Gear, -1) <> 0); |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
893 |
|
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
894 |
Gear^.X:= hx - _1; |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
895 |
collxr:= (TestCollisionX(Gear, 1) <> 0); |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
896 |
|
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
897 |
// restore original value |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
898 |
Gear^.X:= hx; |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
899 |
|
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
900 |
// do nothing if trapped between 2 walls |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
901 |
if collxl = collxr then |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
902 |
break; |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
903 |
|
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
904 |
// if we in a wall - fix that |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
905 |
if collxl then |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
906 |
begin |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
907 |
// check for obstacle |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
908 |
if (TestCollisionX(Gear, 1) <> 0) then |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
909 |
break; |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
910 |
Gear^.X:= Gear^.X + _1; |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
911 |
end |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
912 |
else |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
913 |
begin |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
914 |
// check for obstacle |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
915 |
if (TestCollisionX(Gear, -1) <> 0) then |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
916 |
break; |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
917 |
Gear^.X:= Gear^.X - _1; |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
918 |
end; |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
919 |
|
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
920 |
colly:= (TestCollisionYwithGear(Gear, 1) <> 0); |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
921 |
end; |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
922 |
|
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
923 |
|
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
924 |
end; |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
925 |
|
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
926 |
//////////////////////////////////////////////////////////////////////////////// |
6581 | 927 |
procedure doStepHedgehogMoving(Gear: PGear); |
928 |
var isFalling, isUnderwater: boolean; |
|
929 |
land: Word; |
|
11489 | 930 |
cnt: LongWord; |
6581 | 931 |
begin |
10577
5e075da5e0a4
don't drown unplaced hedgehogs. thanks to zimmux and Wohlstand for reporting
sheepluva
parents:
10443
diff
changeset
|
932 |
if Gear^.Hedgehog^.Unplaced then |
5e075da5e0a4
don't drown unplaced hedgehogs. thanks to zimmux and Wohlstand for reporting
sheepluva
parents:
10443
diff
changeset
|
933 |
begin |
5e075da5e0a4
don't drown unplaced hedgehogs. thanks to zimmux and Wohlstand for reporting
sheepluva
parents:
10443
diff
changeset
|
934 |
Gear^.dY:= _0; |
5e075da5e0a4
don't drown unplaced hedgehogs. thanks to zimmux and Wohlstand for reporting
sheepluva
parents:
10443
diff
changeset
|
935 |
Gear^.dX:= _0; |
5e075da5e0a4
don't drown unplaced hedgehogs. thanks to zimmux and Wohlstand for reporting
sheepluva
parents:
10443
diff
changeset
|
936 |
Gear^.State:= Gear^.State and (not gstMoving); |
5e075da5e0a4
don't drown unplaced hedgehogs. thanks to zimmux and Wohlstand for reporting
sheepluva
parents:
10443
diff
changeset
|
937 |
exit |
5e075da5e0a4
don't drown unplaced hedgehogs. thanks to zimmux and Wohlstand for reporting
sheepluva
parents:
10443
diff
changeset
|
938 |
end; |
5e075da5e0a4
don't drown unplaced hedgehogs. thanks to zimmux and Wohlstand for reporting
sheepluva
parents:
10443
diff
changeset
|
939 |
|
6581 | 940 |
land:= 0; |
10354 | 941 |
isUnderwater:= CheckCoordInWater(hwRound(Gear^.X), hwRound(Gear^.Y) + Gear^.Radius); |
6581 | 942 |
if Gear^.dX.QWordValue > 8160437862 then |
943 |
Gear^.dX.QWordValue:= 8160437862; |
|
944 |
if Gear^.dY.QWordValue > 8160437862 then |
|
945 |
Gear^.dY.QWordValue:= 8160437862; |
|
946 |
||
11517
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
947 |
isFalling:= (Gear^.dY.isNegative); |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
948 |
if (not isFalling) then |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
949 |
begin |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
950 |
// make sure we're not just stuck in wall |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
951 |
moveHedgehogOutOfWall(Gear); |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
952 |
// test for floor/obstacle below |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
953 |
isFalling:= (TestCollisionYKick(Gear, 1) = 0); |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
954 |
end; |
0e305b7153e6
serious anti wall sticking protection for hedgewars
sheepluva
parents:
11515
diff
changeset
|
955 |
|
6581 | 956 |
if isFalling then |
957 |
begin |
|
9731
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
958 |
land:= TestCollisionYKick(Gear, -1); |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
959 |
if (Gear^.dY.isNegative) and (land <> 0) then |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
960 |
begin |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
961 |
if land and lfBouncy <> 0 then |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
962 |
begin |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
963 |
doStepFallingGear(Gear); |
10895
bce67defd804
Make bouncing a bit less wtf for various gears tested (hog, 'zooka, saucer hog, drill strike). Less hacky is another matter.
nemo
parents:
10818
diff
changeset
|
964 |
Gear^.AdvBounce:= 1; |
9731
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
965 |
Gear^.dX:= Gear^.dX * _0_8 |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
966 |
end; |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
967 |
if (land and lfBouncy = 0) or (Gear^.State and gstCollision <> 0) then |
9795
487e5675061f
clear gstCollision from doStepFallingGear once I'm done with it. hog "physics" doesn't use it, and was screwing up labels
nemo
parents:
9776
diff
changeset
|
968 |
Gear^.dY:= _0; |
9954 | 969 |
Gear^.State:= Gear^.State and (not gstCollision) |
9731
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
970 |
end; |
6581 | 971 |
Gear^.State:= Gear^.State or gstMoving; |
9971 | 972 |
if (Gear^.State and gstHHDriven <> 0) and |
11272 | 973 |
(FollowGear <> nil) and |
9499 | 974 |
(not CurrentTeam^.ExtDriven) and (hwSqr(Gear^.dX) + hwSqr(Gear^.dY) > _0_003) then |
6581 | 975 |
begin |
7187
aff30d80bd7b
- Allow camera movement while current hedgehog is falling
unc0rr
parents:
7164
diff
changeset
|
976 |
// TODO: why so aggressive at setting FollowGear when falling? |
9499 | 977 |
// because hog was being yanked out of frame by other stuff when doing a complicated jump/chute/saucer/roping. |
978 |
// added a couple more conditions to make it a bit less aggressive, at cost of possibly spectator failing to follow a maneuver |
|
6581 | 979 |
FollowGear:= Gear; |
980 |
end; |
|
981 |
if isUnderwater then |
|
982 |
Gear^.dY:= Gear^.dY + cGravity / _2 |
|
983 |
else |
|
984 |
begin |
|
985 |
Gear^.dY:= Gear^.dY + cGravity; |
|
986 |
// this set of circumstances could be less complex if jumping was more clearly identified |
|
987 |
if ((GameFlags and gfMoreWind) <> 0) and (((Gear^.Damage <> 0) |
|
988 |
or ((CurAmmoGear <> nil) and ((CurAmmoGear^.AmmoType = amJetpack) or (CurAmmoGear^.AmmoType = amBirdy))) |
|
989 |
or ((Gear^.dY.QWordValue + Gear^.dX.QWordValue) > _0_55.QWordValue))) then |
|
990 |
Gear^.dX := Gear^.dX + cWindSpeed / Gear^.Density |
|
991 |
end |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
992 |
end |
6581 | 993 |
else |
994 |
begin |
|
995 |
land:= TestCollisionYwithGear(Gear, 1); |
|
10015 | 996 |
if ((Gear^.dX.QWordValue + Gear^.dY.QWordValue) < _0_55.QWordValue) and ((land and lfIce) = 0) |
997 |
and ((land and lfBouncy = 0) or (Gear^.State and gstCollision <> 0)) |
|
11515 | 998 |
and (Gear^.Damage = 0) |
6581 | 999 |
and ((Gear^.State and gstHHJumping) <> 0) then |
1000 |
SetLittle(Gear^.dX); |
|
1001 |
||
1002 |
if not Gear^.dY.isNegative then |
|
1003 |
begin |
|
9731
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1004 |
if land and lfBouncy <> 0 then |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1005 |
begin |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1006 |
doStepFallingGear(Gear); |
10895
bce67defd804
Make bouncing a bit less wtf for various gears tested (hog, 'zooka, saucer hog, drill strike). Less hacky is another matter.
nemo
parents:
10818
diff
changeset
|
1007 |
Gear^.AdvBounce:= 1; |
9731
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1008 |
// hogs for some reason have very low friction. slippery little buggers |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1009 |
Gear^.dX:= Gear^.dX * _0_8 |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1010 |
end; |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1011 |
|
6581 | 1012 |
CheckHHDamage(Gear); |
1013 |
||
9731
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1014 |
if (land and lfBouncy = 0) or (Gear^.State and gstCollision <> 0) then |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1015 |
begin |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1016 |
if ((Gear^.State and gstHHHJump) <> 0) and (not cArtillery) |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1017 |
and (Gear^.dX.QWordValue < _0_02.QWordValue) then |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1018 |
begin |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1019 |
if land and lfBouncy <> 0 then |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1020 |
Gear^.dY:= _0; |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1021 |
Gear^.dX.isNegative:= not Gear^.dX.isNegative // landing after high jump |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1022 |
end; |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1023 |
Gear^.State:= Gear^.State and (not (gstHHJumping or gstHHHJump)); |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1024 |
if (land and lfBouncy = 0) or (Gear^.dX.QWordValue < _0_02.QWordValue) then |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1025 |
Gear^.dY:= _0 |
9795
487e5675061f
clear gstCollision from doStepFallingGear once I'm done with it. hog "physics" doesn't use it, and was screwing up labels
nemo
parents:
9776
diff
changeset
|
1026 |
end; |
9954 | 1027 |
Gear^.State:= Gear^.State and (not gstCollision) |
6581 | 1028 |
end |
1029 |
else |
|
1030 |
Gear^.dY:= Gear^.dY + cGravity; |
|
1031 |
||
1032 |
if ((Gear^.State and gstMoving) <> 0) then |
|
1033 |
begin |
|
1034 |
if land and lfIce <> 0 then |
|
1035 |
begin |
|
1036 |
Gear^.dX:= Gear^.dX * (_1 - (_1 - Gear^.Friction) / _2) |
|
1037 |
end |
|
1038 |
else |
|
1039 |
Gear^.dX:= Gear^.dX * Gear^.Friction; |
|
1040 |
end |
|
1041 |
end; |
|
1042 |
||
10146
1fb6d8cc4626
Should never use State like this, since some states aren't synced (thinking state for example)
unc0rr
parents:
10124
diff
changeset
|
1043 |
if (Gear^.State and (gstMoving or gstHHJumping or gstHHHJump)) <> 0 then |
6581 | 1044 |
DeleteCI(Gear); |
1045 |
||
1046 |
if isUnderwater then |
|
1047 |
begin |
|
1048 |
Gear^.dY:= Gear^.dY * _0_999; |
|
1049 |
Gear^.dX:= Gear^.dX * _0_999; |
|
1050 |
end; |
|
1051 |
||
1052 |
if (Gear^.State and gstMoving) <> 0 then |
|
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
1053 |
if TestCollisionXKick(Gear, hwSign(Gear^.dX)) <> 0 then |
6581 | 1054 |
if not isFalling then |
1055 |
if hwAbs(Gear^.dX) > _0_01 then |
|
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
1056 |
if (TestCollisionXwithXYShift(Gear, int2hwFloat(hwSign(Gear^.dX)) - Gear^.dX, -1, hwSign(Gear^.dX)) = 0) and |
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
1057 |
(TestCollisionYwithXYShift(Gear, hwSign(Gear^.dX) - hwRound(Gear^.dX), -1, -1) = 0) then |
6581 | 1058 |
begin |
1059 |
Gear^.X:= Gear^.X + Gear^.dX; |
|
1060 |
Gear^.dX:= Gear^.dX * _0_96; |
|
1061 |
Gear^.Y:= Gear^.Y - _1 |
|
1062 |
end |
|
1063 |
else |
|
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
1064 |
if (TestCollisionXwithXYShift(Gear, int2hwFloat(hwSign(Gear^.dX)) - Gear^.dX, -2, hwSign(Gear^.dX)) = 0) and |
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
1065 |
(TestCollisionYwithXYShift(Gear, hwSign(Gear^.dX) - hwRound(Gear^.dX), -1, -1) = 0) then |
6581 | 1066 |
begin |
1067 |
Gear^.X:= Gear^.X + Gear^.dX; |
|
1068 |
Gear^.dX:= Gear^.dX * _0_93; |
|
1069 |
Gear^.Y:= Gear^.Y - _2 |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
1070 |
end |
6581 | 1071 |
else |
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
1072 |
if (TestCollisionXwithXYShift(Gear, int2hwFloat(hwSign(Gear^.dX)) - Gear^.dX, -3, hwSign(Gear^.dX)) = 0) and |
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
1073 |
(TestCollisionYwithXYShift(Gear, hwSign(Gear^.dX) - hwRound(Gear^.dX), -1, -1) = 0) then |
6581 | 1074 |
begin |
1075 |
Gear^.X:= Gear^.X + Gear^.dX; |
|
1076 |
Gear^.dX:= Gear^.dX * _0_9 ; |
|
1077 |
Gear^.Y:= Gear^.Y - _3 |
|
1078 |
end |
|
1079 |
else |
|
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
1080 |
if (TestCollisionXwithXYShift(Gear, int2hwFloat(hwSign(Gear^.dX)) - Gear^.dX, -4, hwSign(Gear^.dX)) = 0) and |
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
1081 |
(TestCollisionYwithXYShift(Gear, hwSign(Gear^.dX) - hwRound(Gear^.dX), -1, -1) = 0) then |
6581 | 1082 |
begin |
1083 |
Gear^.X:= Gear^.X + Gear^.dX; |
|
1084 |
Gear^.dX:= Gear^.dX * _0_87; |
|
1085 |
Gear^.Y:= Gear^.Y - _4 |
|
1086 |
end |
|
1087 |
else |
|
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
1088 |
if (TestCollisionXwithXYShift(Gear, int2hwFloat(hwSign(Gear^.dX)) - Gear^.dX, -5, hwSign(Gear^.dX)) = 0) and |
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
1089 |
(TestCollisionYwithXYShift(Gear, hwSign(Gear^.dX) - hwRound(Gear^.dX), -1, -1) = 0) then |
6581 | 1090 |
begin |
1091 |
Gear^.X:= Gear^.X + Gear^.dX; |
|
1092 |
Gear^.dX:= Gear^.dX * _0_84; |
|
1093 |
Gear^.Y:= Gear^.Y - _5 |
|
1094 |
end |
|
1095 |
else |
|
1096 |
if hwAbs(Gear^.dX) > _0_02 then |
|
1097 |
Gear^.dX:= -Gear^.Elasticity * Gear^.dX |
|
1098 |
else |
|
1099 |
begin |
|
1100 |
Gear^.State:= Gear^.State and (not gstMoving); |
|
11489 | 1101 |
cnt:= 0; |
1102 |
while (cnt < 6) and (not CheckGearDrowning(Gear)) and (Gear <> nil) and (TestCollisionYWithGear(Gear,1) = 0) do |
|
1103 |
begin |
|
1104 |
Gear^.Y:= Gear^.Y + _1; |
|
1105 |
inc(cnt) |
|
1106 |
end; |
|
1107 |
||
6581 | 1108 |
SetLittle(Gear^.dX) |
1109 |
end |
|
1110 |
else |
|
1111 |
begin |
|
1112 |
Gear^.State:= Gear^.State and (not gstMoving); |
|
11489 | 1113 |
cnt:= 0; |
1114 |
while (cnt < 6) and (not CheckGearDrowning(Gear)) and (Gear <> nil) and (TestCollisionYWithGear(Gear,1) = 0) do |
|
1115 |
begin |
|
1116 |
Gear^.Y:= Gear^.Y + _1; |
|
1117 |
inc(cnt) |
|
1118 |
end; |
|
6581 | 1119 |
SetLittle(Gear^.dX) |
1120 |
end |
|
1121 |
else if (hwAbs(Gear^.dX) > cLittle) |
|
1122 |
and ((Gear^.State and gstHHJumping) = 0) then |
|
1123 |
Gear^.dX:= -Gear^.Elasticity * Gear^.dX |
|
1124 |
else |
|
1125 |
SetLittle(Gear^.dX); |
|
1126 |
||
1127 |
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
|
1128 |
and (hwAbs(Gear^.dX) + hwAbs(Gear^.dY) < _0_03) then |
6581 | 1129 |
begin |
1130 |
Gear^.State:= Gear^.State and (not gstWinner); |
|
1131 |
Gear^.State:= Gear^.State and (not gstMoving); |
|
11489 | 1132 |
cnt:= 0; |
1133 |
while (cnt < 6) and (not CheckGearDrowning(Gear)) and (Gear <> nil) and (TestCollisionYWithGear(Gear,1) = 0) do |
|
1134 |
begin |
|
8947
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8818
diff
changeset
|
1135 |
Gear^.Y:= Gear^.Y + _1; |
11489 | 1136 |
inc(cnt) |
1137 |
end; |
|
8947
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8818
diff
changeset
|
1138 |
|
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8818
diff
changeset
|
1139 |
// 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
|
1140 |
if Gear = nil then exit; |
6581 | 1141 |
SetLittle(Gear^.dX); |
1142 |
Gear^.dY:= _0 |
|
1143 |
end |
|
1144 |
else |
|
1145 |
Gear^.State:= Gear^.State or gstMoving; |
|
1146 |
||
1147 |
if (Gear^.State and gstMoving) <> 0 then |
|
1148 |
begin |
|
1149 |
Gear^.State:= Gear^.State and (not gstAnimation); |
|
1150 |
// ARTILLERY but not being moved by explosions |
|
1151 |
Gear^.X:= Gear^.X + Gear^.dX; |
|
1152 |
Gear^.Y:= Gear^.Y + Gear^.dY; |
|
9731
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1153 |
if (not Gear^.dY.isNegative) and (TestCollisionYKick(Gear, 1) = 0) then |
6581 | 1154 |
begin |
9731
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1155 |
land:= TestCollisionYwithXYShift(Gear, 0, 1, 1); |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1156 |
if land and lfBouncy <> 0 then |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1157 |
doStepFallingGear(Gear); |
10895
bce67defd804
Make bouncing a bit less wtf for various gears tested (hog, 'zooka, saucer hog, drill strike). Less hacky is another matter.
nemo
parents:
10818
diff
changeset
|
1158 |
Gear^.AdvBounce:= 1; |
9731
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1159 |
|
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1160 |
if (land <> 0) and ((land and lfBouncy = 0) or (Gear^.State and gstCollision <> 0)) then |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1161 |
begin |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1162 |
CheckHHDamage(Gear); |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1163 |
Gear^.dY:= _0; |
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset
|
1164 |
Gear^.Y:= Gear^.Y + _1 |
9795
487e5675061f
clear gstCollision from doStepFallingGear once I'm done with it. hog "physics" doesn't use it, and was screwing up labels
nemo
parents:
9776
diff
changeset
|
1165 |
end; |
9954 | 1166 |
Gear^.State:= Gear^.State and (not gstCollision) |
6581 | 1167 |
end; |
8947
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8818
diff
changeset
|
1168 |
|
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8818
diff
changeset
|
1169 |
// 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
|
1170 |
if Gear = nil then exit; |
6581 | 1171 |
// hide target cursor if current hog is drowning |
1172 |
if (Gear^.State and gstDrowning) <> 0 then |
|
1173 |
if (CurrentHedgehog^.Gear = Gear) then |
|
1174 |
isCursorVisible:= false |
|
1175 |
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
|
1176 |
if (not isZero(Gear^.dY)) and (Gear^.FlightTime > 0) and ((GameFlags and gfLowGravity) = 0) then |
6581 | 1177 |
begin |
1178 |
inc(Gear^.FlightTime); |
|
8003 | 1179 |
if (Gear^.FlightTime > 1500) and ((hwRound(Gear^.X) < LongInt(leftX)-250) or (hwRound(Gear^.X) > LongInt(rightX)+250)) then |
6581 | 1180 |
begin |
7763 | 1181 |
Gear^.FlightTime:= 0; |
6581 | 1182 |
AddCaption(GetEventString(eidHomerun), cWhiteColor, capgrpMessage); |
1183 |
PlaySound(sndHomerun) |
|
1184 |
end; |
|
1185 |
end |
|
1186 |
else |
|
1187 |
begin |
|
1188 |
uStats.hedgehogFlight(Gear, Gear^.FlightTime); |
|
1189 |
Gear^.FlightTime:= 0; |
|
1190 |
end; |
|
1191 |
||
1192 |
end; |
|
1193 |
||
1194 |
procedure doStepHedgehogDriven(HHGear: PGear); |
|
1195 |
var t: PGear; |
|
1196 |
wasJumping: boolean; |
|
1197 |
Hedgehog: PHedgehog; |
|
1198 |
begin |
|
1199 |
Hedgehog:= HHGear^.Hedgehog; |
|
8658 | 1200 |
if not isInMultiShoot then |
1201 |
AllInactive:= false |
|
1202 |
else if Hedgehog^.CurAmmoType in [amShotgun, amDEagle, amSniperRifle] then |
|
1203 |
HHGear^.Message:= 0; |
|
6581 | 1204 |
|
8330 | 1205 |
if ((Ammoz[CurrentHedgehog^.CurAmmoType].Ammo.Propz and ammoprop_Utility) <> 0) and isInMultiShoot then |
6581 | 1206 |
AllInactive:= true |
7786
23a075cf4837
*sigh* revert the multishoot thingy. worked fine in my tests w/ smine and cleaver, screwed up deagle. need to find out why, but sleepy. for later
nemo
parents:
7783
diff
changeset
|
1207 |
else if not isInMultiShoot then |
6581 | 1208 |
AllInactive:= false; |
1209 |
||
1210 |
if (TurnTimeLeft = 0) or (HHGear^.Damage > 0) then |
|
1211 |
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
|
1212 |
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
|
1213 |
LoadHedgehogHat(Hedgehog^, Hedgehog^.Hat); |
6581 | 1214 |
if TagTurnTimeLeft = 0 then |
1215 |
TagTurnTimeLeft:= TurnTimeLeft; |
|
1216 |
TurnTimeLeft:= 0; |
|
1217 |
isCursorVisible:= false; |
|
1218 |
HHGear^.State:= HHGear^.State and (not (gstHHDriven or gstAnimation or gstAttacking)); |
|
1219 |
AttackBar:= 0; |
|
1220 |
if HHGear^.Damage > 0 then |
|
1221 |
HHGear^.State:= HHGear^.State and (not (gstHHJumping or gstHHHJump)); |
|
1222 |
exit |
|
1223 |
end; |
|
1224 |
||
9670
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset
|
1225 |
if isAFK and (not CurrentTeam^.ExtDriven) and (CurrentHedgehog^.BotLevel = 0) then |
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset
|
1226 |
begin |
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset
|
1227 |
AFKSkip; |
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset
|
1228 |
exit |
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset
|
1229 |
end; |
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset
|
1230 |
|
6581 | 1231 |
if (HHGear^.State and gstAnimation) <> 0 then |
1232 |
begin |
|
1233 |
HHGear^.Message:= 0; |
|
1234 |
if (HHGear^.Pos = Wavez[TWave(HHGear^.Tag)].VoiceDelay) and (HHGear^.Timer = 0) then |
|
7053 | 1235 |
PlaySoundV(Wavez[TWave(HHGear^.Tag)].Voice, Hedgehog^.Team^.voicepack); |
6581 | 1236 |
inc(HHGear^.Timer); |
1237 |
if HHGear^.Timer = Wavez[TWave(HHGear^.Tag)].Interval then |
|
1238 |
begin |
|
1239 |
HHGear^.Timer:= 0; |
|
1240 |
inc(HHGear^.Pos); |
|
1241 |
if HHGear^.Pos = Wavez[TWave(HHGear^.Tag)].FramesCount then |
|
1242 |
HHGear^.State:= HHGear^.State and (not gstAnimation) |
|
1243 |
end; |
|
1244 |
exit |
|
1245 |
end; |
|
1246 |
||
1247 |
if ((HHGear^.State and gstMoving) <> 0) |
|
7028 | 1248 |
or (GHStepTicks = cHHStepTicks) |
6581 | 1249 |
or (CurAmmoGear <> nil) then // we are moving |
1250 |
begin |
|
1251 |
with Hedgehog^ do |
|
1252 |
if (CurAmmoGear = nil) |
|
1253 |
and (HHGear^.dY > _0_39) |
|
1254 |
and (CurAmmoType = amParachute) then |
|
1255 |
HHGear^.Message:= HHGear^.Message or gmAttack; |
|
1256 |
// check for case with ammo |
|
1257 |
t:= CheckGearNear(HHGear, gtCase, 36, 36); |
|
11629 | 1258 |
if (t <> nil) then |
6581 | 1259 |
PickUp(HHGear, t) |
1260 |
end; |
|
1261 |
||
1262 |
if (CurAmmoGear = nil) then |
|
1263 |
if (((HHGear^.Message and gmAttack) <> 0) |
|
1264 |
or ((HHGear^.State and gstAttacking) <> 0)) then |
|
1265 |
Attack(HHGear) // should be before others to avoid desync with '/put' msg and changing weapon msgs |
|
1266 |
else |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
1267 |
else |
6581 | 1268 |
with Hedgehog^ do |
1269 |
if ((Ammoz[CurAmmoGear^.AmmoType].Ammo.Propz and ammoprop_AltAttack) <> 0) |
|
1270 |
and ((HHGear^.Message and gmLJump) <> 0) |
|
1271 |
and ((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_AltUse) <> 0) then |
|
1272 |
begin |
|
1273 |
Attack(HHGear); |
|
1274 |
HHGear^.Message:= HHGear^.Message and (not gmLJump) |
|
1275 |
end; |
|
1276 |
||
1277 |
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
|
1278 |
or ((Ammoz[CurAmmoGear^.AmmoType].Ammo.Propz and ammoprop_AltAttack) <> 0) then |
6581 | 1279 |
begin |
1280 |
if ((HHGear^.Message and gmSlot) <> 0) then |
|
1281 |
if ChangeAmmo(HHGear) then ApplyAmmoChanges(Hedgehog^); |
|
1282 |
||
1283 |
if ((HHGear^.Message and gmWeapon) <> 0) then |
|
1284 |
HHSetWeapon(HHGear); |
|
1285 |
||
1286 |
if ((HHGear^.Message and gmTimer) <> 0) then |
|
1287 |
HHSetTimer(HHGear); |
|
1288 |
end; |
|
1289 |
||
1290 |
if CurAmmoGear <> nil then |
|
1291 |
begin |
|
1292 |
CurAmmoGear^.Message:= HHGear^.Message; |
|
1293 |
exit |
|
1294 |
end; |
|
1295 |
||
1296 |
HedgehogChAngle(HHGear); |
|
1297 |
||
1298 |
if (HHGear^.State and gstMoving) <> 0 then |
|
1299 |
begin |
|
1300 |
wasJumping:= ((HHGear^.State and gstHHJumping) <> 0); |
|
1301 |
||
1302 |
if ((HHGear^.Message and gmHJump) <> 0) and wasJumping and ((HHGear^.State and gstHHHJump) = 0) then |
|
1303 |
if (not (hwAbs(HHGear^.dX) > cLittle)) and (HHGear^.dY < -_0_02) then |
|
1304 |
begin |
|
1305 |
HHGear^.State:= HHGear^.State or gstHHHJump; |
|
1306 |
HHGear^.dY:= -_0_25; |
|
1307 |
if not cArtillery then |
|
1308 |
HHGear^.dX:= -SignAs(_0_02, HHGear^.dX); |
|
7053 | 1309 |
PlaySoundV(sndJump2, Hedgehog^.Team^.voicepack) |
6581 | 1310 |
end; |
1311 |
||
1312 |
HHGear^.Message:= HHGear^.Message and (not (gmLJump or gmHJump)); |
|
1313 |
||
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
1314 |
if (not cArtillery) and wasJumping and (TestCollisionXwithGear(HHGear, hwSign(HHGear^.dX)) <> 0) then |
6581 | 1315 |
SetLittle(HHGear^.dX); |
1316 |
||
1317 |
if Hedgehog^.Gear <> nil then |
|
1318 |
doStepHedgehogMoving(HHGear); |
|
1319 |
||
1320 |
if ((HHGear^.State and (gstMoving or gstDrowning)) = 0) then |
|
1321 |
begin |
|
9291
15f7bb217b66
Make add/delete consistent (this has bugged me for so long)
nemo
parents:
9285
diff
changeset
|
1322 |
AddCI(HHGear); |
6581 | 1323 |
if wasJumping then |
7028 | 1324 |
GHStepTicks:= 410 |
6581 | 1325 |
else |
7028 | 1326 |
GHStepTicks:= 95 |
6581 | 1327 |
end; |
1328 |
exit |
|
1329 |
end; |
|
1330 |
||
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
|
1331 |
if not(isInMultiShoot and (Hedgehog^.CurAmmoType in [amShotgun, amDEagle, amSniperRifle])) and (Hedgehog^.Gear <> nil) then |
6581 | 1332 |
begin |
7028 | 1333 |
if GHStepTicks > 0 then |
1334 |
dec(GHStepTicks); |
|
1335 |
if (GHStepTicks = 0) then |
|
6581 | 1336 |
HedgehogStep(HHGear) |
1337 |
end |
|
1338 |
end; |
|
1339 |
||
1340 |
//////////////////////////////////////////////////////////////////////////////// |
|
1341 |
procedure doStepHedgehogFree(Gear: PGear); |
|
1342 |
var prevState: Longword; |
|
10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10123
diff
changeset
|
1343 |
s: ansistring; |
6581 | 1344 |
begin |
1345 |
prevState:= Gear^.State; |
|
1346 |
||
1347 |
doStepHedgehogMoving(Gear); |
|
1348 |
||
1349 |
if (Gear^.State and (gstMoving or gstDrowning)) <> 0 then |
|
1350 |
begin |
|
1351 |
if Gear^.Damage > 0 then |
|
1352 |
CalcRotationDirAngle(Gear); |
|
1353 |
AllInactive:= false; |
|
1354 |
exit |
|
1355 |
end; |
|
1356 |
||
1357 |
if (Gear^.Health = 0) then |
|
1358 |
begin |
|
1359 |
if PrvInactive or ((GameFlags and gfInfAttack) <> 0) then |
|
1360 |
begin |
|
1361 |
Gear^.Timer:= 0; |
|
1362 |
FollowGear:= Gear; |
|
1363 |
PrvInactive:= false; |
|
1364 |
AllInactive:= false; |
|
1365 |
||
1366 |
if (Gear^.State and gstHHGone) = 0 then |
|
1367 |
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
|
1368 |
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
|
1369 |
if Gear^.Hedgehog^.Effects[heResurrectable] <> 0 then |
6581 | 1370 |
begin |
1371 |
ResurrectHedgehog(Gear); |
|
1372 |
end |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
1373 |
else |
6581 | 1374 |
begin |
1375 |
Gear^.State:= (Gear^.State or gstHHDeath) and (not gstAnimation); |
|
1376 |
Gear^.doStep:= @doStepHedgehogDead; |
|
1377 |
// Death message |
|
10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10123
diff
changeset
|
1378 |
s:= ansistring(Gear^.Hedgehog^.Name); |
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10123
diff
changeset
|
1379 |
AddCaption(FormatA(GetEventString(eidDied), s), cWhiteColor, capgrpMessage); |
6581 | 1380 |
end; |
1381 |
end |
|
1382 |
else |
|
1383 |
begin |
|
1384 |
Gear^.State:= Gear^.State and (not gstAnimation); |
|
1385 |
Gear^.doStep:= @doStepHedgehogGone; |
|
1386 |
||
1387 |
// Gone message |
|
10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10123
diff
changeset
|
1388 |
s:= ansistring(Gear^.Hedgehog^.Name); |
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10123
diff
changeset
|
1389 |
AddCaption(FormatA(GetEventString(eidGone), s), cWhiteColor, capgrpMessage); |
6581 | 1390 |
end |
1391 |
end; |
|
1392 |
exit |
|
1393 |
end; |
|
1394 |
||
1395 |
if ((Gear^.State and gstWait) = 0) and |
|
1396 |
(prevState <> Gear^.State) then |
|
1397 |
begin |
|
1398 |
Gear^.State:= Gear^.State or gstWait; |
|
1399 |
Gear^.Timer:= 150 |
|
1400 |
end |
|
1401 |
else |
|
1402 |
begin |
|
1403 |
if Gear^.Timer = 0 then |
|
1404 |
begin |
|
10818
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
1405 |
Gear^.State:= Gear^.State and (not (gstWait or gstLoser or gstWinner or gstAttacked or gstNotKickable or gstChooseTarget)); |
8563
4d9d8287e601
Trying to improve rendering, sliding and thawing. Messing around w/ making fire thaw faster.
nemo
parents:
8560
diff
changeset
|
1406 |
if Gear^.Hedgehog^.Effects[heFrozen] = 0 then Gear^.Active:= false; |
9291
15f7bb217b66
Make add/delete consistent (this has bugged me for so long)
nemo
parents:
9285
diff
changeset
|
1407 |
AddCI(Gear); |
6581 | 1408 |
exit |
1409 |
end |
|
1410 |
else dec(Gear^.Timer) |
|
1411 |
end; |
|
1412 |
||
1413 |
AllInactive:= false |
|
1414 |
end; |
|
1415 |
||
8574 | 1416 |
procedure CheckIce(Gear: PGear); inline; |
6581 | 1417 |
(* |
1418 |
var x,y,tx,ty: LongInt; |
|
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
1419 |
tdX, tdY, slope: hwFloat; |
6581 | 1420 |
land: Word; *) |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
1421 |
var slope: hwFloat; |
6581 | 1422 |
begin |
8574 | 1423 |
if (Gear^.Message and (gmAllStoppable or gmLJump or gmHJump) = 0) |
1424 |
and (Gear^.State and (gstHHJumping or gstHHHJump or gstAttacking) = 0) |
|
8633 | 1425 |
and ((Gear^.Hedgehog = nil) or ((Gear^.Hedgehog^.Effects[heFrozen] = 0) or (Gear^.Hedgehog^.Effects[heFrozen] > 255))) |
9672
8663d299ba62
this should prevent sliding when game clock isn't running. sorry unc0rr, not going to bother encapsulating. maybe later. short on time right now/lazy
nemo
parents:
9670
diff
changeset
|
1426 |
and (not Gear^.dY.isNegative) and TurnClockActive and (TestCollisionYwithGear(Gear, 1) and lfIce <> 0) then |
8574 | 1427 |
begin |
1428 |
slope:= CalcSlopeBelowGear(Gear); |
|
1429 |
if slope.QWordValue > 730144440 then // ignore mild slopes |
|
1430 |
begin |
|
1431 |
Gear^.dX:=Gear^.dX+slope*cGravity*_256; |
|
1432 |
Gear^.State:= Gear^.State or gstMoving |
|
1433 |
end |
|
1434 |
end; |
|
1435 |
(* |
|
1436 |
x:= hwRound(Gear^.X); |
|
1437 |
y:= hwRound(Gear^.Y); |
|
1438 |
AddVisualGear(x, y, vgtSmokeTrace); |
|
1439 |
AddVisualGear(x - hwRound(_5*slope), y + hwRound(_5*slope), vgtSmokeTrace); |
|
1440 |
AddVisualGear(x + hwRound(_5*slope), y - hwRound(_5*slope), vgtSmokeTrace); |
|
1441 |
AddVisualGear(x - hwRound(_20 * slope), y + hwRound(_20 * slope), vgtSmokeTrace); |
|
1442 |
AddVisualGear(x + hwRound(_20 * slope), y - hwRound(_20 * slope), vgtSmokeTrace); |
|
1443 |
AddVisualGear(x - hwRound(_30 * slope), y + hwRound(_30 * slope), vgtSmokeTrace); |
|
1444 |
AddVisualGear(x + hwRound(_30 * slope), y - hwRound(_30 * slope), vgtSmokeTrace); |
|
1445 |
AddVisualGear(x - hwRound(_40 * slope), y + hwRound(_40 * slope), vgtSmokeTrace); |
|
1446 |
AddVisualGear(x + hwRound(_40 * slope), y - hwRound(_40 * slope), vgtSmokeTrace); |
|
1447 |
AddVisualGear(x - hwRound(_50 * slope), y + hwRound(_50 * slope), vgtSmokeTrace); |
|
1448 |
AddVisualGear(x + hwRound(_50 * slope), y - hwRound(_50 * slope), vgtSmokeTrace); *) |
|
1449 |
end; |
|
1450 |
||
1451 |
//////////////////////////////////////////////////////////////////////////////// |
|
1452 |
procedure doStepHedgehog(Gear: PGear); |
|
9526 | 1453 |
var tX: hwFloat; |
8574 | 1454 |
begin |
10577
5e075da5e0a4
don't drown unplaced hedgehogs. thanks to zimmux and Wohlstand for reporting
sheepluva
parents:
10443
diff
changeset
|
1455 |
// it might make sense to skip more than just drowning check here |
5e075da5e0a4
don't drown unplaced hedgehogs. thanks to zimmux and Wohlstand for reporting
sheepluva
parents:
10443
diff
changeset
|
1456 |
if (not Gear^.Hedgehog^.Unplaced) then |
5e075da5e0a4
don't drown unplaced hedgehogs. thanks to zimmux and Wohlstand for reporting
sheepluva
parents:
10443
diff
changeset
|
1457 |
CheckGearDrowning(Gear); |
9917 | 1458 |
if Gear = nil then exit; |
9526 | 1459 |
tX:= Gear^.X; |
1460 |
if WorldWrap(Gear) then |
|
1461 |
begin |
|
10015 | 1462 |
if (WorldEdge <> weBounce) and (Gear = CurrentHedgehog^.Gear) and |
9539 | 1463 |
(CurAmmoGear <> nil) and (CurAmmoGear^.Kind =gtRope) and (CurAmmoGear^.Elasticity <> _0) then |
9526 | 1464 |
CurAmmoGear^.PortalCounter:= 1; |
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
1465 |
if (WorldEdge = weWrap) and ((TestCollisionXwithGear(Gear, 1) <> 0) or (TestCollisionXwithGear(Gear, -1) <> 0)) then |
9526 | 1466 |
begin |
1467 |
Gear^.X:= tX; |
|
9809 | 1468 |
Gear^.dX.isNegative:= (hwRound(tX) > LongInt(leftX) + Gear^.Radius * 2) |
9526 | 1469 |
end |
1470 |
end; |
|
9507 | 1471 |
|
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
|
1472 |
CheckSum:= CheckSum xor Gear^.Hedgehog^.BotLevel; |
6581 | 1473 |
if (Gear^.Message and gmDestroy) <> 0 then |
1474 |
begin |
|
1475 |
DeleteGear(Gear); |
|
1476 |
exit |
|
1477 |
end; |
|
9670
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset
|
1478 |
if GameTicks mod 128 = 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
|
1479 |
(* |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
1480 |
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
|
1481 |
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
|
1482 |
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
|
1483 |
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
|
1484 |
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
|
1485 |
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
|
1486 |
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
|
1487 |
*) |
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset
|
1488 |
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
|
1489 |
dec(Gear^.Hedgehog^.Effects[heFrozen]); |
6581 | 1490 |
if (Gear^.State and gstHHDriven) = 0 then |
1491 |
doStepHedgehogFree(Gear) |
|
1492 |
else |
|
1493 |
begin |
|
1494 |
with Gear^.Hedgehog^ do |
|
1495 |
if Team^.hasGone then |
|
1496 |
TeamGoneEffect(Team^) |
|
1497 |
else |
|
1498 |
doStepHedgehogDriven(Gear) |
|
1499 |
end; |
|
1500 |
end; |
|
1501 |
||
1502 |
end. |