author | Grigory Ustinov <grenka@altlinux.org> |
Thu, 26 Sep 2019 16:35:46 +0300 | |
changeset 15442 | 85ed38cc5f8f |
parent 15301 | b12f63054c94 |
child 15647 | 1b044b47773b |
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 uGearsUtils; |
|
22 |
interface |
|
9285 | 23 |
uses uTypes, uFloat; |
6581 | 24 |
|
6986
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6888
diff
changeset
|
25 |
procedure doMakeExplosion(X, Y, Radius: LongInt; AttackingHog: PHedgehog; Mask: Longword); inline; |
8330 | 26 |
procedure doMakeExplosion(X, Y, Radius: LongInt; AttackingHog: PHedgehog; Mask: Longword; const Tint: LongWord); |
10363 | 27 |
procedure AddSplashForGear(Gear: PGear; justSkipping: boolean); |
13609
13f68f3e7153
Add bounce effect to cake when it touches bounce edge
Wuzzy <Wuzzy2@mail.ru>
parents:
13604
diff
changeset
|
28 |
procedure AddBounceEffectForGear(Gear: PGear; imageScale: Single); |
10508 | 29 |
procedure AddBounceEffectForGear(Gear: PGear); |
6986
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6888
diff
changeset
|
30 |
|
6581 | 31 |
function ModifyDamage(dmg: Longword; Gear: PGear): Longword; |
32 |
procedure ApplyDamage(Gear: PGear; AttackerHog: PHedgehog; Damage: Longword; Source: TDamageSource); |
|
33 |
procedure spawnHealthTagForHH(HHGear: PGear; dmg: Longword); |
|
14062
44f20c9e6861
Add Ouch taunt for particulary damaging hits (fall, bullet, shove, hammer)
Wuzzy <Wuzzy2@mail.ru>
parents:
14061
diff
changeset
|
34 |
procedure HHHurt(Hedgehog: PHedgehog; Source: TDamageSource; Damage: Longword); |
13617
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
35 |
procedure HHHeal(Hedgehog: PHedgehog; healthBoost: LongInt; showMessage: boolean; vgTint: Longword); |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
36 |
procedure HHHeal(Hedgehog: PHedgehog; healthBoost: LongInt; showMessage: boolean); |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
37 |
function IncHogHealth(Hedgehog: PHedgehog; healthBoost: LongInt): LongInt; |
6581 | 38 |
procedure CheckHHDamage(Gear: PGear); |
39 |
procedure CalcRotationDirAngle(Gear: PGear); |
|
8947
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8763
diff
changeset
|
40 |
procedure ResurrectHedgehog(var gear: PGear); |
6986
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6888
diff
changeset
|
41 |
|
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6888
diff
changeset
|
42 |
procedure FindPlace(var Gear: PGear; withFall: boolean; Left, Right: LongInt); inline; |
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6888
diff
changeset
|
43 |
procedure FindPlace(var Gear: PGear; withFall: boolean; Left, Right: LongInt; skipProximity: boolean); |
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6888
diff
changeset
|
44 |
|
13399 | 45 |
function CheckGearNear(Kind: TGearType; X, Y: hwFloat; rX, rY: LongInt): PGear; |
6581 | 46 |
function CheckGearNear(Gear: PGear; Kind: TGearType; rX, rY: LongInt): PGear; |
8947
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8763
diff
changeset
|
47 |
function CheckGearDrowning(var Gear: PGear): boolean; |
7592 | 48 |
procedure CheckCollision(Gear: PGear); inline; |
49 |
procedure CheckCollisionWithLand(Gear: PGear); inline; |
|
6581 | 50 |
|
9285 | 51 |
procedure AmmoShove(Ammo: PGear; Damage, Power: LongInt); |
14027
105793e575d6
make firepunch hit moving gears (airmines are not amused)
alfadur
parents:
14026
diff
changeset
|
52 |
procedure AmmoShoveCache(Ammo: PGear; Damage, Power: LongInt); |
12898 | 53 |
procedure AmmoShoveLine(Ammo: PGear; Damage, Power: LongInt; oX, oY, tX, tY: hwFloat); |
9285 | 54 |
function GearsNear(X, Y: hwFloat; Kind: TGearType; r: LongInt): PGearArrayS; |
14789
185f07ec4d12
New callback: onCaseDrop (called when engine MIGHT drop a crate)
Wuzzy <Wuzzy2@mail.ru>
parents:
14770
diff
changeset
|
55 |
function SpawnBoxOfSmth: PGear; |
185f07ec4d12
New callback: onCaseDrop (called when engine MIGHT drop a crate)
Wuzzy <Wuzzy2@mail.ru>
parents:
14770
diff
changeset
|
56 |
procedure PlayBoxSpawnTaunt(Gear: PGear); |
9285 | 57 |
procedure ShotgunShot(Gear: PGear); |
12712
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
58 |
function CanUseTardis(HHGear: PGear): boolean; |
9285 | 59 |
|
60 |
procedure SetAllToActive; |
|
61 |
procedure SetAllHHToActive(Ice: boolean); |
|
9954 | 62 |
procedure SetAllHHToActive(); inline; |
9285 | 63 |
|
64 |
function GetAmmo(Hedgehog: PHedgehog): TAmmoType; |
|
65 |
function GetUtility(Hedgehog: PHedgehog): TAmmoType; |
|
66 |
||
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
67 |
function WorldWrap(var Gear: PGear): boolean; |
14535
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
68 |
function HomingWrap(var Gear: PGear): boolean; |
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
69 |
|
15015
d9de740e194c
Add utility function to get hog left/right looking dir
Wuzzy <Wuzzy2@mail.ru>
parents:
14947
diff
changeset
|
70 |
function IsHogFacingLeft(Gear: PGear): boolean; |
11847 | 71 |
function IsHogLocal(HH: PHedgehog): boolean; |
9285 | 72 |
|
73 |
||
7719
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
74 |
function MakeHedgehogsStep(Gear: PGear) : boolean; |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
75 |
|
6581 | 76 |
var doStepHandlers: array[TGearType] of TGearStepProcedure; |
77 |
||
78 |
implementation |
|
9285 | 79 |
uses uSound, uCollisions, uUtils, uConsts, uVisualGears, uAIMisc, |
6581 | 80 |
uVariables, uLandGraphics, uScript, uStats, uCaptions, uTeams, uStore, |
10015 | 81 |
uLocale, uTextures, uRenderUtils, uRandom, SDLh, uDebug, |
9285 | 82 |
uGearsList, Math, uVisualGearsList, uGearsHandlersMess, |
83 |
uGearsHedgehog; |
|
6581 | 84 |
|
6986
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6888
diff
changeset
|
85 |
procedure doMakeExplosion(X, Y, Radius: LongInt; AttackingHog: PHedgehog; Mask: Longword); inline; |
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6888
diff
changeset
|
86 |
begin |
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6888
diff
changeset
|
87 |
doMakeExplosion(X, Y, Radius, AttackingHog, Mask, $FFFFFFFF); |
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6888
diff
changeset
|
88 |
end; |
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6888
diff
changeset
|
89 |
|
6581 | 90 |
procedure doMakeExplosion(X, Y, Radius: LongInt; AttackingHog: PHedgehog; Mask: Longword; const Tint: LongWord); |
91 |
var Gear: PGear; |
|
6769
44ad49a3a126
Add drowning to grenade too, try some little optimisations
nemo
parents:
6765
diff
changeset
|
92 |
dmg, dmgBase: LongInt; |
6765 | 93 |
fX, fY, tdX, tdY: hwFloat; |
6581 | 94 |
vg: PVisualGear; |
95 |
i, cnt: LongInt; |
|
10653 | 96 |
wrap: boolean; |
10827 | 97 |
bubble: PVisualGear; |
12169
869cf5f34700
More ticker messages: Sick, king died, resurrect, time box return, timeout, kamikaze
Wuzzy <almikes@aol.com>
parents:
12150
diff
changeset
|
98 |
s: ansistring; |
6581 | 99 |
begin |
100 |
if Radius > 4 then AddFileLog('Explosion: at (' + inttostr(x) + ',' + inttostr(y) + ')'); |
|
101 |
if Radius > 25 then KickFlakes(Radius, X, Y); |
|
102 |
||
103 |
if ((Mask and EXPLNoGfx) = 0) then |
|
104 |
begin |
|
105 |
vg:= nil; |
|
10827 | 106 |
if CheckCoordInWater(X, Y - Radius) then |
107 |
begin |
|
108 |
cnt:= 2 * Radius; |
|
109 |
for i:= (Radius * Radius) div 4 downto 0 do |
|
110 |
begin |
|
111 |
bubble := AddVisualGear(X - Radius + random(cnt), Y - Radius + random(cnt), vgtBubble); |
|
112 |
if bubble <> nil then |
|
113 |
bubble^.dY:= 0.1 + random(20)/10; |
|
114 |
end |
|
115 |
end |
|
116 |
else if Radius > 50 then vg:= AddVisualGear(X, Y, vgtBigExplosion) |
|
6581 | 117 |
else if Radius > 10 then vg:= AddVisualGear(X, Y, vgtExplosion); |
118 |
if vg <> nil then |
|
119 |
vg^.Tint:= Tint; |
|
120 |
end; |
|
121 |
if (Mask and EXPLAutoSound) <> 0 then PlaySound(sndExplosion); |
|
122 |
||
6765 | 123 |
dmgBase:= Radius shl 1 + cHHRadius div 2; |
10653 | 124 |
|
125 |
// we might have to run twice if weWrap is enabled |
|
126 |
wrap:= false; |
|
10659 | 127 |
repeat |
10653 | 128 |
|
10654 | 129 |
fX:= int2hwFloat(X); |
130 |
fY:= int2hwFloat(Y); |
|
131 |
Gear:= GearsList; |
|
132 |
||
6581 | 133 |
while Gear <> nil do |
134 |
begin |
|
135 |
dmg:= 0; |
|
136 |
if (Gear^.State and gstNoDamage) = 0 then |
|
137 |
begin |
|
138 |
case Gear^.Kind of |
|
139 |
gtHedgehog, |
|
140 |
gtMine, |
|
141 |
gtBall, |
|
142 |
gtMelonPiece, |
|
143 |
gtGrenade, |
|
144 |
gtClusterBomb, |
|
145 |
gtSMine, |
|
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:
10668
diff
changeset
|
146 |
gtAirMine, |
6581 | 147 |
gtCase, |
148 |
gtTarget, |
|
149 |
gtFlame, |
|
7754 | 150 |
gtKnife, |
14217
ab5e710d353d
Remove all traces of dead code related to amStructure/gtStructure
Wuzzy <Wuzzy2@mail.ru>
parents:
14062
diff
changeset
|
151 |
gtExplosives: begin |
6581 | 152 |
// Run the calcs only once we know we have a type that will need damage |
6765 | 153 |
tdX:= Gear^.X-fX; |
154 |
tdY:= Gear^.Y-fY; |
|
7721 | 155 |
if LongInt(tdX.Round + tdY.Round + 2) < dmgBase then |
7272
71df899c4163
Second part of the change. Make collision check use the new mask bit.
nemo
parents:
7190
diff
changeset
|
156 |
dmg:= dmgBase - hwRound(Distance(tdX, tdY)); |
6581 | 157 |
if dmg > 1 then |
158 |
begin |
|
159 |
dmg:= ModifyDamage(min(dmg div 2, Radius), Gear); |
|
160 |
//AddFileLog('Damage: ' + inttostr(dmg)); |
|
161 |
if (Mask and EXPLNoDamage) = 0 then |
|
162 |
begin |
|
10011
ead5e4b21671
Add check for gear kind of hedgehog on invulnerability effect. This probably fixes bug #766, is similar to change in previous r2a1483d91977 and was introduced by r7d925e82e572
nemo
parents:
10010
diff
changeset
|
163 |
if (Gear^.Kind <> gtHedgehog) or (Gear^.Hedgehog^.Effects[heInvulnerable] = 0) then |
6581 | 164 |
ApplyDamage(Gear, AttackingHog, dmg, dsExplosion) |
165 |
else |
|
166 |
Gear^.State:= Gear^.State or gstWinner; |
|
167 |
end; |
|
168 |
if ((Mask and EXPLDoNotTouchAny) = 0) and (((Mask and EXPLDoNotTouchHH) = 0) or (Gear^.Kind <> gtHedgehog)) then |
|
169 |
begin |
|
170 |
DeleteCI(Gear); |
|
6765 | 171 |
Gear^.dX:= Gear^.dX + SignAs(_0_005 * dmg + cHHKick, tdX)/(Gear^.Density/_3); |
172 |
Gear^.dY:= Gear^.dY + SignAs(_0_005 * dmg + cHHKick, tdY)/(Gear^.Density/_3); |
|
6581 | 173 |
|
174 |
Gear^.State:= (Gear^.State or gstMoving) and (not gstLoser); |
|
7767 | 175 |
if Gear^.Kind = gtKnife then Gear^.State:= Gear^.State and (not gstCollision); |
10011
ead5e4b21671
Add check for gear kind of hedgehog on invulnerability effect. This probably fixes bug #766, is similar to change in previous r2a1483d91977 and was introduced by r7d925e82e572
nemo
parents:
10010
diff
changeset
|
176 |
if (Gear^.Kind = gtHedgehog) and (Gear^.Hedgehog^.Effects[heInvulnerable] = 0) then |
14947
60340c8a6fae
Don't remove gstWinner after GameOver
Wuzzy <Wuzzy2@mail.ru>
parents:
14789
diff
changeset
|
177 |
begin |
60340c8a6fae
Don't remove gstWinner after GameOver
Wuzzy <Wuzzy2@mail.ru>
parents:
14789
diff
changeset
|
178 |
Gear^.State:= (Gear^.State or gstMoving) and (not (gstHHJumping or gstHHHJump)); |
60340c8a6fae
Don't remove gstWinner after GameOver
Wuzzy <Wuzzy2@mail.ru>
parents:
14789
diff
changeset
|
179 |
if (not GameOver) then |
60340c8a6fae
Don't remove gstWinner after GameOver
Wuzzy <Wuzzy2@mail.ru>
parents:
14789
diff
changeset
|
180 |
Gear^.State:= (Gear^.State and (not gstWinner)); |
60340c8a6fae
Don't remove gstWinner after GameOver
Wuzzy <Wuzzy2@mail.ru>
parents:
14789
diff
changeset
|
181 |
end; |
6581 | 182 |
Gear^.Active:= true; |
14224 | 183 |
if Gear^.Kind <> gtFlame then FollowGear:= Gear; |
184 |
if Gear^.Kind = gtAirMine then |
|
185 |
begin |
|
186 |
Gear^.Tag:= 1; |
|
187 |
Gear^.FlightTime:= 5000; |
|
188 |
end |
|
6581 | 189 |
end; |
11867 | 190 |
if ((Mask and EXPLPoisoned) <> 0) and (Gear^.Kind = gtHedgehog) and |
191 |
(Gear^.Hedgehog^.Effects[heInvulnerable] = 0) and (Gear^.Hedgehog^.Effects[heFrozen] = 0) and |
|
192 |
(Gear^.State and gstHHDeath = 0) then |
|
12169
869cf5f34700
More ticker messages: Sick, king died, resurrect, time box return, timeout, kamikaze
Wuzzy <almikes@aol.com>
parents:
12150
diff
changeset
|
193 |
begin |
869cf5f34700
More ticker messages: Sick, king died, resurrect, time box return, timeout, kamikaze
Wuzzy <almikes@aol.com>
parents:
12150
diff
changeset
|
194 |
if Gear^.Hedgehog^.Effects[hePoisoned] = 0 then |
869cf5f34700
More ticker messages: Sick, king died, resurrect, time box return, timeout, kamikaze
Wuzzy <almikes@aol.com>
parents:
12150
diff
changeset
|
195 |
begin |
869cf5f34700
More ticker messages: Sick, king died, resurrect, time box return, timeout, kamikaze
Wuzzy <almikes@aol.com>
parents:
12150
diff
changeset
|
196 |
s:= ansistring(Gear^.Hedgehog^.Name); |
13642
3d14950641a4
Refactor text color variable names, export 2 color values to Lua
Wuzzy <Wuzzy2@mail.ru>
parents:
13629
diff
changeset
|
197 |
AddCaption(FormatA(GetEventString(eidPoisoned), s), capcolDefault, capgrpMessage); |
12176
29f1ea94488b
Fix enemy saying “Missed” when poisoned w/o damage
Wuzzy <almikes@aol.com>
parents:
12169
diff
changeset
|
198 |
uStats.HedgehogPoisoned(Gear, AttackingHog) |
12169
869cf5f34700
More ticker messages: Sick, king died, resurrect, time box return, timeout, kamikaze
Wuzzy <almikes@aol.com>
parents:
12150
diff
changeset
|
199 |
end; |
869cf5f34700
More ticker messages: Sick, king died, resurrect, time box return, timeout, kamikaze
Wuzzy <almikes@aol.com>
parents:
12150
diff
changeset
|
200 |
Gear^.Hedgehog^.Effects[hePoisoned] := 5; |
869cf5f34700
More ticker messages: Sick, king died, resurrect, time box return, timeout, kamikaze
Wuzzy <almikes@aol.com>
parents:
12150
diff
changeset
|
201 |
end |
6581 | 202 |
end; |
203 |
||
204 |
end; |
|
9814 | 205 |
gtGrave: if Mask and EXPLDoNotTouchAny = 0 then |
6581 | 206 |
// Run the calcs only once we know we have a type that will need damage |
207 |
begin |
|
9814 | 208 |
tdX:= Gear^.X-fX; |
209 |
tdY:= Gear^.Y-fY; |
|
210 |
if LongInt(tdX.Round + tdY.Round + 2) < dmgBase then |
|
211 |
dmg:= dmgBase - hwRound(Distance(tdX, tdY)); |
|
212 |
if dmg > 1 then |
|
213 |
begin |
|
214 |
dmg:= ModifyDamage(min(dmg div 2, Radius), Gear); |
|
215 |
Gear^.dY:= - _0_004 * dmg; |
|
216 |
Gear^.Active:= true |
|
217 |
end |
|
218 |
end; |
|
6581 | 219 |
end; |
220 |
end; |
|
221 |
Gear:= Gear^.NextGear |
|
222 |
end; |
|
223 |
||
224 |
if (Mask and EXPLDontDraw) = 0 then |
|
13604
73b096e1d895
Fix hammer/pickhammer not digging land with gfSolidLand on
Wuzzy <Wuzzy2@mail.ru>
parents:
13597
diff
changeset
|
225 |
if ((GameFlags and gfSolidLand) = 0) or ((Mask and EXPLForceDraw) <> 0) then |
6581 | 226 |
begin |
227 |
cnt:= DrawExplosion(X, Y, Radius) div 1608; // approx 2 16x16 circles to erase per chunk |
|
228 |
if (cnt > 0) and (SpritesData[sprChunk].Texture <> nil) then |
|
229 |
for i:= 0 to cnt do |
|
230 |
AddVisualGear(X, Y, vgtChunk) |
|
231 |
end; |
|
232 |
||
10653 | 233 |
if (WorldEdge = weWrap) then |
234 |
begin |
|
235 |
// already wrapped? let's not wrap again! |
|
236 |
if wrap then |
|
237 |
break; |
|
238 |
||
239 |
// Radius + 5 because that's the actual radius the explosion changes graphically |
|
14303
6015b74eea55
overall, using LongInt for leftX/rightX results in fewer casts, since most comparisons are against ints.
nemo
parents:
14224
diff
changeset
|
240 |
if X + (Radius + 5) > rightX then |
10653 | 241 |
begin |
242 |
dec(X, playWidth); |
|
243 |
wrap:= true; |
|
244 |
end |
|
14303
6015b74eea55
overall, using LongInt for leftX/rightX results in fewer casts, since most comparisons are against ints.
nemo
parents:
14224
diff
changeset
|
245 |
else if X - (Radius + 5) < leftX then |
10653 | 246 |
begin |
247 |
inc(X, playWidth); |
|
248 |
wrap:= true; |
|
249 |
end; |
|
250 |
end; |
|
251 |
||
252 |
until (not wrap); |
|
253 |
||
6581 | 254 |
uAIMisc.AwareOfExplosion(0, 0, 0) |
255 |
end; |
|
256 |
||
257 |
function ModifyDamage(dmg: Longword; Gear: PGear): Longword; |
|
258 |
var i: hwFloat; |
|
259 |
begin |
|
260 |
(* Invulnerability cannot be placed in here due to still needing kicks |
|
261 |
Not without a new damage machine. |
|
262 |
King check should be in here instead of ApplyDamage since Tiy wants them kicked less |
|
263 |
*) |
|
264 |
i:= _1; |
|
265 |
if (CurrentHedgehog <> nil) and CurrentHedgehog^.King then |
|
266 |
i:= _1_5; |
|
10015 | 267 |
if (Gear^.Kind = gtHedgehog) and (Gear^.Hedgehog <> nil) and |
10010
2a1483d91977
well. let's fix this at least - only apply to gears that are actually hedgehogs, not just ones associated with a hedgehog (which can be pretty much any gear since damage tracking was added)
nemo
parents:
9998
diff
changeset
|
268 |
(Gear^.Hedgehog^.King or (Gear^.Hedgehog^.Effects[heFrozen] > 0)) then |
9148
78c699d8fdfd
move 0.01 to the end to avoid increase damage fail on small values like fire. thanks to hedgewars wiki for noting this for fire damage.
nemo
parents:
9080
diff
changeset
|
269 |
ModifyDamage:= hwRound(cDamageModifier * dmg * i * cDamagePercent * _0_5 * _0_01) |
9149 | 270 |
else |
10526
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10512
diff
changeset
|
271 |
ModifyDamage:= hwRound(cDamageModifier * dmg * i * cDamagePercent * _0_01); |
6581 | 272 |
end; |
273 |
||
274 |
procedure ApplyDamage(Gear: PGear; AttackerHog: PHedgehog; Damage: Longword; Source: TDamageSource); |
|
12937
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
275 |
var vampDmg, tmpDmg, i: Longword; |
6581 | 276 |
vg: PVisualGear; |
277 |
begin |
|
278 |
if Damage = 0 then |
|
279 |
exit; // nothing to apply |
|
280 |
||
281 |
if (Gear^.Kind = gtHedgehog) then |
|
282 |
begin |
|
283 |
Gear^.LastDamage := AttackerHog; |
|
284 |
||
285 |
Gear^.Hedgehog^.Team^.Clan^.Flawless:= false; |
|
15216
7d41e7889123
Explode hog instantly when taking damage while dying
Wuzzy <Wuzzy2@mail.ru>
parents:
15202
diff
changeset
|
286 |
|
15301
b12f63054c94
No longer explode dying hogs that take damage
Wuzzy <Wuzzy2@mail.ru>
parents:
15248
diff
changeset
|
287 |
if (Gear^.State and gstHHDeath) = 0 then |
15216
7d41e7889123
Explode hog instantly when taking damage while dying
Wuzzy <Wuzzy2@mail.ru>
parents:
15202
diff
changeset
|
288 |
begin |
7d41e7889123
Explode hog instantly when taking damage while dying
Wuzzy <Wuzzy2@mail.ru>
parents:
15202
diff
changeset
|
289 |
HHHurt(Gear^.Hedgehog, Source, Damage); |
7d41e7889123
Explode hog instantly when taking damage while dying
Wuzzy <Wuzzy2@mail.ru>
parents:
15202
diff
changeset
|
290 |
AddDamageTag(hwRound(Gear^.X), hwRound(Gear^.Y), Damage, Gear^.Hedgehog^.Team^.Clan^.Color); |
7d41e7889123
Explode hog instantly when taking damage while dying
Wuzzy <Wuzzy2@mail.ru>
parents:
15202
diff
changeset
|
291 |
end; |
7d41e7889123
Explode hog instantly when taking damage while dying
Wuzzy <Wuzzy2@mail.ru>
parents:
15202
diff
changeset
|
292 |
|
6581 | 293 |
tmpDmg:= min(Damage, max(0,Gear^.Health-Gear^.Damage)); |
294 |
if (Gear <> CurrentHedgehog^.Gear) and (CurrentHedgehog^.Gear <> nil) and (tmpDmg >= 1) then |
|
295 |
begin |
|
296 |
if cVampiric then |
|
297 |
begin |
|
298 |
vampDmg:= hwRound(int2hwFloat(tmpDmg)*_0_8); |
|
299 |
if vampDmg >= 1 then |
|
300 |
begin |
|
301 |
// was considering pulsing on attack, Tiy thinks it should be permanent while in play |
|
302 |
//CurrentHedgehog^.Gear^.State:= CurrentHedgehog^.Gear^.State or gstVampiric; |
|
13617
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
303 |
vampDmg:= IncHogHealth(CurrentHedgehog, vampDmg); |
6581 | 304 |
RenderHealth(CurrentHedgehog^); |
305 |
RecountTeamHealth(CurrentHedgehog^.Team); |
|
12937
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
306 |
HHHeal(CurrentHedgehog, vampDmg, true, $FF0000FF); |
6581 | 307 |
end |
308 |
end; |
|
12289
c20fbf96b853
Fix hedgehog self-damage not counted, and there were never Stupid taunts/announces
Wuzzy <almikes@aol.com>
parents:
12209
diff
changeset
|
309 |
if (GameFlags and gfKarma <> 0) and (GameFlags and gfInvulnerable = 0) and |
c20fbf96b853
Fix hedgehog self-damage not counted, and there were never Stupid taunts/announces
Wuzzy <almikes@aol.com>
parents:
12209
diff
changeset
|
310 |
(CurrentHedgehog^.Effects[heInvulnerable] = 0) then |
c20fbf96b853
Fix hedgehog self-damage not counted, and there were never Stupid taunts/announces
Wuzzy <almikes@aol.com>
parents:
12209
diff
changeset
|
311 |
begin // this cannot just use Damage or it interrupts shotgun and gets you called stupid |
c20fbf96b853
Fix hedgehog self-damage not counted, and there were never Stupid taunts/announces
Wuzzy <almikes@aol.com>
parents:
12209
diff
changeset
|
312 |
inc(CurrentHedgehog^.Gear^.Karma, tmpDmg); |
c20fbf96b853
Fix hedgehog self-damage not counted, and there were never Stupid taunts/announces
Wuzzy <almikes@aol.com>
parents:
12209
diff
changeset
|
313 |
CurrentHedgehog^.Gear^.LastDamage := CurrentHedgehog; |
c20fbf96b853
Fix hedgehog self-damage not counted, and there were never Stupid taunts/announces
Wuzzy <almikes@aol.com>
parents:
12209
diff
changeset
|
314 |
spawnHealthTagForHH(CurrentHedgehog^.Gear, tmpDmg); |
c20fbf96b853
Fix hedgehog self-damage not counted, and there were never Stupid taunts/announces
Wuzzy <almikes@aol.com>
parents:
12209
diff
changeset
|
315 |
end; |
6581 | 316 |
end; |
12289
c20fbf96b853
Fix hedgehog self-damage not counted, and there were never Stupid taunts/announces
Wuzzy <almikes@aol.com>
parents:
12209
diff
changeset
|
317 |
|
8330 | 318 |
uStats.HedgehogDamaged(Gear, AttackerHog, Damage, false); |
10526
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10512
diff
changeset
|
319 |
|
15202 | 320 |
if AprilOne and (Gear^.Hedgehog^.Hat = 'fr_tomato') and (Damage > 2) then |
321 |
for i := 0 to random(min(Damage,20))+5 do |
|
322 |
begin |
|
323 |
vg:= AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtStraightShot); |
|
324 |
if vg <> nil then |
|
325 |
with vg^ do |
|
326 |
begin |
|
327 |
dx:= 0.001 * (random(100)+10); |
|
328 |
dy:= 0.001 * (random(100)+10); |
|
329 |
tdy:= -cGravityf; |
|
330 |
if random(2) = 0 then |
|
331 |
dx := -dx; |
|
332 |
FrameTicks:= random(500) + 1000; |
|
333 |
State:= ord(sprBubbles); |
|
334 |
Tint:= $ff0000ff |
|
335 |
end |
|
336 |
end |
|
8199
886ed135665b
Fix crashes and wtf behaviour introduced in r0b8beacff8a5
unc0rr
parents:
8161
diff
changeset
|
337 |
end else |
6581 | 338 |
Gear^.Hedgehog:= AttackerHog; |
339 |
inc(Gear^.Damage, Damage); |
|
8330 | 340 |
|
6581 | 341 |
ScriptCall('onGearDamage', Gear^.UID, Damage); |
342 |
end; |
|
343 |
||
344 |
procedure spawnHealthTagForHH(HHGear: PGear; dmg: Longword); |
|
345 |
var tag: PVisualGear; |
|
346 |
begin |
|
347 |
tag:= AddVisualGear(hwRound(HHGear^.X), hwRound(HHGear^.Y), vgtHealthTag, dmg); |
|
348 |
if (tag <> nil) then |
|
349 |
tag^.Hedgehog:= HHGear^.Hedgehog; // the tag needs the tag to determine the text color |
|
350 |
AllInactive:= false; |
|
351 |
HHGear^.Active:= true; |
|
352 |
end; |
|
8330 | 353 |
|
12937
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
354 |
// Play effects for hurt hedgehog |
14062
44f20c9e6861
Add Ouch taunt for particulary damaging hits (fall, bullet, shove, hammer)
Wuzzy <Wuzzy2@mail.ru>
parents:
14061
diff
changeset
|
355 |
procedure HHHurt(Hedgehog: PHedgehog; Source: TDamageSource; Damage: Longword); |
6581 | 356 |
begin |
9071 | 357 |
if Hedgehog^.Effects[heFrozen] <> 0 then exit; |
10526
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10512
diff
changeset
|
358 |
|
14062
44f20c9e6861
Add Ouch taunt for particulary damaging hits (fall, bullet, shove, hammer)
Wuzzy <Wuzzy2@mail.ru>
parents:
14061
diff
changeset
|
359 |
if (Damage >= ouchDmg) and (OuchTauntTimer = 0) and ((Source = dsFall) or (Source = dsBullet) or (Source = dsShove) or (Source = dsHammer)) then |
44f20c9e6861
Add Ouch taunt for particulary damaging hits (fall, bullet, shove, hammer)
Wuzzy <Wuzzy2@mail.ru>
parents:
14061
diff
changeset
|
360 |
begin |
44f20c9e6861
Add Ouch taunt for particulary damaging hits (fall, bullet, shove, hammer)
Wuzzy <Wuzzy2@mail.ru>
parents:
14061
diff
changeset
|
361 |
PlaySoundV(sndOuch, Hedgehog^.Team^.voicepack); |
44f20c9e6861
Add Ouch taunt for particulary damaging hits (fall, bullet, shove, hammer)
Wuzzy <Wuzzy2@mail.ru>
parents:
14061
diff
changeset
|
362 |
// Prevent sndOuch from being played too often in short time |
44f20c9e6861
Add Ouch taunt for particulary damaging hits (fall, bullet, shove, hammer)
Wuzzy <Wuzzy2@mail.ru>
parents:
14061
diff
changeset
|
363 |
OuchTauntTimer:= 1250; |
44f20c9e6861
Add Ouch taunt for particulary damaging hits (fall, bullet, shove, hammer)
Wuzzy <Wuzzy2@mail.ru>
parents:
14061
diff
changeset
|
364 |
end |
44f20c9e6861
Add Ouch taunt for particulary damaging hits (fall, bullet, shove, hammer)
Wuzzy <Wuzzy2@mail.ru>
parents:
14061
diff
changeset
|
365 |
else if (Source = dsFall) or (Source = dsExplosion) then |
6581 | 366 |
case random(3) of |
7053 | 367 |
0: PlaySoundV(sndOoff1, Hedgehog^.Team^.voicepack); |
368 |
1: PlaySoundV(sndOoff2, Hedgehog^.Team^.voicepack); |
|
369 |
2: PlaySoundV(sndOoff3, Hedgehog^.Team^.voicepack); |
|
6581 | 370 |
end |
371 |
else if (Source = dsPoison) then |
|
372 |
case random(2) of |
|
7053 | 373 |
0: PlaySoundV(sndPoisonCough, Hedgehog^.Team^.voicepack); |
374 |
1: PlaySoundV(sndPoisonMoan, Hedgehog^.Team^.voicepack); |
|
6581 | 375 |
end |
376 |
else |
|
377 |
case random(4) of |
|
7053 | 378 |
0: PlaySoundV(sndOw1, Hedgehog^.Team^.voicepack); |
379 |
1: PlaySoundV(sndOw2, Hedgehog^.Team^.voicepack); |
|
380 |
2: PlaySoundV(sndOw3, Hedgehog^.Team^.voicepack); |
|
381 |
3: PlaySoundV(sndOw4, Hedgehog^.Team^.voicepack); |
|
6581 | 382 |
end |
383 |
end; |
|
384 |
||
12937
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
385 |
{- |
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
386 |
Show heal particles and message at hog gear. |
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
387 |
Hedgehog: Hedgehog which gets the health boost |
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
388 |
healthBoost: Amount of added health added |
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
389 |
showMessage: Whether to show announcer message |
13617
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
390 |
vgTint: Tint of heal particle (if 0, don't render particles) |
12937
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
391 |
-} |
13617
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
392 |
procedure HHHeal(Hedgehog: PHedgehog; healthBoost: LongInt; showMessage: boolean; vgTint: Longword); |
12937
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
393 |
var i: LongInt; |
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
394 |
vg: PVisualGear; |
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
395 |
s: ansistring; |
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
396 |
begin |
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
397 |
if healthBoost < 1 then |
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
398 |
exit; |
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
399 |
|
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
400 |
if showMessage then |
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
401 |
begin |
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
402 |
s:= IntToStr(healthBoost); |
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
403 |
AddCaption(FormatA(trmsg[sidHealthGain], s), Hedgehog^.Team^.Clan^.Color, capgrpAmmoinfo) |
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
404 |
end; |
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
405 |
|
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
406 |
i:= 0; |
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
407 |
// One particle for every 5 HP. Max. 200 particles |
13617
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
408 |
if (vgTint <> 0) then |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
409 |
while (i < healthBoost) and (i < 1000) do |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
410 |
begin |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
411 |
vg:= AddVisualGear(hwRound(Hedgehog^.Gear^.X), hwRound(Hedgehog^.Gear^.Y), vgtStraightShot); |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
412 |
if vg <> nil then |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
413 |
with vg^ do |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
414 |
begin |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
415 |
Tint:= vgTint; |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
416 |
State:= ord(sprHealth) |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
417 |
end; |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
418 |
inc(i, 5) |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
419 |
end; |
12937
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
420 |
end; |
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
421 |
|
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
422 |
// Shorthand for the same above, but with tint implied |
13617
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
423 |
procedure HHHeal(Hedgehog: PHedgehog; healthBoost: LongInt; showMessage: boolean); |
12937
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
424 |
begin |
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
425 |
HHHeal(Hedgehog, healthBoost, showMessage, $00FF00FF); |
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
426 |
end; |
a84a05719454
Refactor health gain effects and message into util fuction HHHeal
Wuzzy <Wuzzy2@mail.ru>
parents:
12920
diff
changeset
|
427 |
|
13617
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
428 |
// Increase hog health by healthBoost (at least 1). |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
429 |
// Resulting health is capped at cMaxHogHealth. |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
430 |
// Returns actual amount healed. |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
431 |
function IncHogHealth(Hedgehog: PHedgehog; healthBoost: LongInt): LongInt; |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
432 |
var oldHealth: LongInt; |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
433 |
begin |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
434 |
if healthBoost < 1 then |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
435 |
begin |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
436 |
IncHogHealth:= 0; |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
437 |
exit; |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
438 |
end; |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
439 |
oldHealth:= Hedgehog^.Gear^.Health; |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
440 |
inc(Hedgehog^.Gear^.Health, healthBoost); |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
441 |
// Prevent overflow |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
442 |
if (Hedgehog^.Gear^.Health < 1) or (Hedgehog^.Gear^.Health > cMaxHogHealth) then |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
443 |
Hedgehog^.Gear^.Health:= cMaxHogHealth; |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
444 |
IncHogHealth:= Hedgehog^.Gear^.Health - oldHealth; |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
445 |
end; |
a6abc2c1fc1a
Show correct health increase when hog health cap is reached
Wuzzy <Wuzzy2@mail.ru>
parents:
13609
diff
changeset
|
446 |
|
6581 | 447 |
procedure CheckHHDamage(Gear: PGear); |
10015 | 448 |
var |
9809 | 449 |
dmg: LongInt; |
8003 | 450 |
i: LongWord; |
6581 | 451 |
particle: PVisualGear; |
452 |
begin |
|
9071 | 453 |
if _0_4 < Gear^.dY then |
454 |
begin |
|
455 |
dmg := ModifyDamage(1 + hwRound((Gear^.dY - _0_4) * 70), Gear); |
|
456 |
if Gear^.Hedgehog^.Effects[heFrozen] = 0 then |
|
457 |
PlaySound(sndBump) |
|
458 |
else PlaySound(sndFrozenHogImpact); |
|
459 |
if dmg < 1 then |
|
460 |
exit; |
|
6581 | 461 |
|
9809 | 462 |
for i:= min(12, 3 + dmg div 10) downto 0 do |
9071 | 463 |
begin |
464 |
particle := AddVisualGear(hwRound(Gear^.X) - 5 + Random(10), hwRound(Gear^.Y) + 12, vgtDust); |
|
465 |
if particle <> nil then |
|
466 |
particle^.dX := particle^.dX + (Gear^.dX.QWordValue / 21474836480); |
|
467 |
end; |
|
6581 | 468 |
|
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:
9561
diff
changeset
|
469 |
if ((Gear^.Hedgehog^.Effects[heInvulnerable] <> 0)) then |
9071 | 470 |
exit; |
6581 | 471 |
|
9071 | 472 |
if Gear^.LastDamage <> nil then |
473 |
ApplyDamage(Gear, Gear^.LastDamage, dmg, dsFall) |
|
474 |
else |
|
475 |
ApplyDamage(Gear, CurrentHedgehog, dmg, dsFall); |
|
6581 | 476 |
end |
477 |
end; |
|
478 |
||
479 |
||
480 |
procedure CalcRotationDirAngle(Gear: PGear); |
|
8330 | 481 |
var |
6581 | 482 |
dAngle: real; |
483 |
begin |
|
7825 | 484 |
// Frac/Round to be kind to JS as of 2012-08-27 where there is yet no int64/uint64 |
485 |
dAngle := (Gear^.dX.Round + Gear^.dY.Round) / 2 + (Gear^.dX.Frac/$100000000+Gear^.dY.Frac/$100000000); |
|
6581 | 486 |
if not Gear^.dX.isNegative then |
487 |
Gear^.DirAngle := Gear^.DirAngle + dAngle |
|
488 |
else |
|
489 |
Gear^.DirAngle := Gear^.DirAngle - dAngle; |
|
490 |
||
491 |
if Gear^.DirAngle < 0 then |
|
492 |
Gear^.DirAngle := Gear^.DirAngle + 360 |
|
493 |
else if 360 < Gear^.DirAngle then |
|
494 |
Gear^.DirAngle := Gear^.DirAngle - 360 |
|
495 |
end; |
|
496 |
||
10363 | 497 |
procedure AddSplashForGear(Gear: PGear; justSkipping: boolean); |
498 |
var x, y, i, distL, distR, distB, minDist, maxDrops: LongInt; |
|
499 |
splash, particle: PVisualGear; |
|
500 |
speed, hwTmp: hwFloat; |
|
501 |
vi, vs, tmp: real; // impact speed and sideways speed |
|
502 |
isImpactH, isImpactRight: boolean; |
|
10419 | 503 |
const dist2surf = 4; |
10363 | 504 |
begin |
505 |
x:= hwRound(Gear^.X); |
|
506 |
y:= hwRound(Gear^.Y); |
|
507 |
||
10419 | 508 |
// find position for splash and impact speed |
10363 | 509 |
|
510 |
distB:= cWaterline - y; |
|
511 |
||
512 |
if WorldEdge <> weSea then |
|
513 |
minDist:= distB |
|
514 |
else |
|
515 |
begin |
|
516 |
distL:= x - leftX; |
|
517 |
distR:= rightX - x; |
|
518 |
minDist:= min(distB, min(distL, distR)); |
|
519 |
end; |
|
520 |
||
521 |
isImpactH:= (minDist <> distB); |
|
522 |
||
523 |
if not isImpactH then |
|
524 |
begin |
|
10417 | 525 |
y:= cWaterline - dist2surf; |
10363 | 526 |
speed:= hwAbs(Gear^.dY); |
527 |
end |
|
528 |
else |
|
529 |
begin |
|
530 |
isImpactRight := minDist = distR; |
|
531 |
if isImpactRight then |
|
10419 | 532 |
x:= rightX - dist2surf |
10363 | 533 |
else |
10419 | 534 |
x:= leftX + dist2surf; |
10363 | 535 |
speed:= hwAbs(Gear^.dX); |
536 |
end; |
|
537 |
||
538 |
// splash sound |
|
539 |
||
540 |
if justSkipping then |
|
541 |
PlaySound(sndSkip) |
|
542 |
else |
|
543 |
begin |
|
544 |
// adjust water impact sound based on gear speed and density |
|
545 |
hwTmp:= hwAbs(Gear^.Density * speed); |
|
546 |
||
547 |
if hwTmp > _1 then |
|
548 |
PlaySound(sndSplash) |
|
549 |
else if hwTmp > _0_5 then |
|
550 |
PlaySound(sndSkip) |
|
12150 | 551 |
else if hwTmp > _0_0002 then // arbitrary sanity cutoff. mostly for airmines |
10363 | 552 |
PlaySound(sndDroplet2); |
553 |
end; |
|
554 |
||
10419 | 555 |
|
556 |
// splash visuals |
|
557 |
||
558 |
if ((cReducedQuality and rqPlainSplash) <> 0) then |
|
559 |
exit; |
|
560 |
||
561 |
splash:= AddVisualGear(x, y, vgtSplash); |
|
562 |
if splash = nil then |
|
563 |
exit; |
|
564 |
||
565 |
if not isImpactH then |
|
566 |
vs:= abs(hwFloat2Float(Gear^.dX)) |
|
567 |
else |
|
568 |
begin |
|
569 |
if isImpactRight then |
|
570 |
splash^.Angle:= -90 |
|
571 |
else |
|
572 |
splash^.Angle:= 90; |
|
573 |
vs:= abs(hwFloat2Float(Gear^.dY)); |
|
574 |
end; |
|
575 |
||
576 |
||
577 |
vi:= hwFloat2Float(speed); |
|
578 |
||
10363 | 579 |
with splash^ do |
580 |
begin |
|
581 |
Scale:= abs(hwFloat2Float(Gear^.Density / _3 * speed)); |
|
582 |
if Scale > 1 then Scale:= power(Scale,0.3333) |
|
583 |
else Scale:= Scale + ((1-Scale) / 2); |
|
584 |
if Scale > 1 then Timer:= round(min(Scale*0.0005/cGravityf,4)) |
|
585 |
else Timer:= 1; |
|
15248
263b9850c16d
Tweak position of big splashes right or left
Wuzzy <Wuzzy2@mail.ru>
parents:
15244
diff
changeset
|
586 |
if Scale > 1 then |
263b9850c16d
Tweak position of big splashes right or left
Wuzzy <Wuzzy2@mail.ru>
parents:
15244
diff
changeset
|
587 |
if (not isImpactH) then |
263b9850c16d
Tweak position of big splashes right or left
Wuzzy <Wuzzy2@mail.ru>
parents:
15244
diff
changeset
|
588 |
Y:= Y + 10 |
263b9850c16d
Tweak position of big splashes right or left
Wuzzy <Wuzzy2@mail.ru>
parents:
15244
diff
changeset
|
589 |
else if isImpactRight then |
263b9850c16d
Tweak position of big splashes right or left
Wuzzy <Wuzzy2@mail.ru>
parents:
15244
diff
changeset
|
590 |
X:= X + 10 |
263b9850c16d
Tweak position of big splashes right or left
Wuzzy <Wuzzy2@mail.ru>
parents:
15244
diff
changeset
|
591 |
else |
263b9850c16d
Tweak position of big splashes right or left
Wuzzy <Wuzzy2@mail.ru>
parents:
15244
diff
changeset
|
592 |
X:= X - 10; |
10363 | 593 |
// Low Gravity |
594 |
FrameTicks:= FrameTicks*Timer; |
|
595 |
end; |
|
596 |
||
597 |
||
598 |
// eject water drops |
|
599 |
||
600 |
maxDrops := (hwRound(Gear^.Density) * 3) div 2 + round((vi + vs) * hwRound(Gear^.Density) * 6); |
|
601 |
for i:= max(maxDrops div 3, min(32, Random(maxDrops))) downto 0 do |
|
602 |
begin |
|
603 |
if isImpactH then |
|
604 |
particle := AddVisualGear(x, y - 3 + Random(7), vgtDroplet) |
|
605 |
else |
|
606 |
particle := AddVisualGear(x - 3 + Random(7), y, vgtDroplet); |
|
607 |
||
608 |
if particle <> nil then |
|
609 |
with particle^ do |
|
610 |
begin |
|
611 |
// dX and dY were initialized to have a random value on creation (see uVisualGearsList) |
|
612 |
if isImpactH then |
|
613 |
begin |
|
614 |
tmp:= dX; |
|
615 |
if isImpactRight then |
|
616 |
dX:= dY - vi / 5 |
|
617 |
else |
|
618 |
dX:= -dy + vi / 5; |
|
619 |
dY:= tmp * (1 + vs / 10); |
|
620 |
end |
|
621 |
else |
|
622 |
begin |
|
623 |
dX:= dX * (1 + vs / 10); |
|
624 |
dY:= dY - vi / 5; |
|
625 |
end; |
|
626 |
||
627 |
if splash <> nil then |
|
628 |
begin |
|
629 |
if splash^.Scale > 1 then |
|
630 |
begin |
|
631 |
dX:= dX * power(splash^.Scale, 0.3333); // tone down the droplet height further |
|
632 |
dY:= dY * power(splash^.Scale, 0.3333); |
|
633 |
end |
|
634 |
else |
|
635 |
begin |
|
636 |
dX:= dX * splash^.Scale; |
|
637 |
dY:= dY * splash^.Scale; |
|
638 |
end; |
|
639 |
end; |
|
640 |
end |
|
641 |
end; |
|
642 |
||
643 |
end; |
|
644 |
||
10354 | 645 |
procedure DrownGear(Gear: PGear); |
646 |
begin |
|
647 |
Gear^.doStep := @doStepDrowningGear; |
|
648 |
||
649 |
Gear^.Timer := 5000; // how long game should wait |
|
650 |
end; |
|
651 |
||
8947
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8763
diff
changeset
|
652 |
function CheckGearDrowning(var Gear: PGear): boolean; |
10015 | 653 |
var |
10363 | 654 |
skipSpeed, skipAngle, skipDecay: hwFloat; |
655 |
tmp, X, Y, dist2Water: LongInt; |
|
656 |
isSubmersible, isDirH, isImpact, isSkip: boolean; |
|
10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10116
diff
changeset
|
657 |
s: ansistring; |
6581 | 658 |
begin |
659 |
// probably needs tweaking. might need to be in a case statement based upon gear type |
|
10354 | 660 |
X:= hwRound(Gear^.X); |
6581 | 661 |
Y:= hwRound(Gear^.Y); |
10354 | 662 |
|
663 |
dist2Water:= cWaterLine - (Y + Gear^.Radius); |
|
10363 | 664 |
isDirH:= false; |
10354 | 665 |
|
666 |
if WorldEdge = weSea then |
|
6581 | 667 |
begin |
10363 | 668 |
tmp:= dist2Water; |
14303
6015b74eea55
overall, using LongInt for leftX/rightX results in fewer casts, since most comparisons are against ints.
nemo
parents:
14224
diff
changeset
|
669 |
dist2Water:= min(dist2Water, min(X - Gear^.Radius - leftX, rightX - (X + Gear^.Radius))); |
10363 | 670 |
// if water on sides is closer than on bottom -> horizontal direction |
671 |
isDirH:= tmp <> dist2Water; |
|
10354 | 672 |
end; |
673 |
||
10363 | 674 |
isImpact:= false; |
675 |
||
10354 | 676 |
if dist2Water < 0 then |
677 |
begin |
|
678 |
// invisible gears will just be deleted |
|
679 |
// unless they are generic fallers, then they will be "respawned" |
|
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:
7372
diff
changeset
|
680 |
if Gear^.State and gstInvisible <> 0 then |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7372
diff
changeset
|
681 |
begin |
7406
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7389
diff
changeset
|
682 |
if Gear^.Kind = gtGenericFaller then |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7389
diff
changeset
|
683 |
begin |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7389
diff
changeset
|
684 |
Gear^.X:= int2hwFloat(GetRandom(rightX-leftX)+leftX); |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7389
diff
changeset
|
685 |
Gear^.Y:= int2hwFloat(GetRandom(LAND_HEIGHT-topY)+topY); |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7389
diff
changeset
|
686 |
Gear^.dX:= _90-(GetRandomf*_360); |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7389
diff
changeset
|
687 |
Gear^.dY:= _90-(GetRandomf*_360) |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7389
diff
changeset
|
688 |
end |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7389
diff
changeset
|
689 |
else DeleteGear(Gear); |
10245 | 690 |
exit(true) |
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:
7372
diff
changeset
|
691 |
end; |
8992
5b0be812dcdb
Rename submersible state, increase getaway time for attack underwater, slow down gear dx/dy underwater to simulate water resistance
nemo
parents:
8991
diff
changeset
|
692 |
isSubmersible:= ((Gear = CurrentHedgehog^.Gear) and (CurAmmoGear <> nil) and (CurAmmoGear^.State and gstSubmersible <> 0)) or (Gear^.State and gstSubmersible <> 0); |
10363 | 693 |
|
6581 | 694 |
skipSpeed := _0_25; |
695 |
skipAngle := _1_9; |
|
696 |
skipDecay := _0_87; |
|
10363 | 697 |
|
10354 | 698 |
|
699 |
// skipping |
|
700 |
||
10512
25021aac078e
fix underwater-skipping bug and make air-strike missiles submersible when fired from within weSea
sheepluva
parents:
10508
diff
changeset
|
701 |
if (not isSubmersible) and (hwSqr(Gear^.dX) + hwSqr(Gear^.dY) > skipSpeed) |
10363 | 702 |
and ( ((not isDirH) and (hwAbs(Gear^.dX) > skipAngle * hwAbs(Gear^.dY))) |
703 |
or (isDirH and (hwAbs(Gear^.dY) > skipAngle * hwAbs(Gear^.dX))) ) then |
|
6581 | 704 |
begin |
10363 | 705 |
isSkip:= true; |
10354 | 706 |
// if skipping we move the gear out of water |
10363 | 707 |
if isDirH then |
10354 | 708 |
begin |
709 |
Gear^.dX.isNegative := (not Gear^.dX.isNegative); |
|
710 |
Gear^.X:= Gear^.X + Gear^.dX; |
|
711 |
end |
|
712 |
else |
|
713 |
begin |
|
714 |
Gear^.dY.isNegative := (not Gear^.dY.isNegative); |
|
715 |
Gear^.Y:= Gear^.Y + Gear^.dY; |
|
716 |
end; |
|
6581 | 717 |
Gear^.dY := Gear^.dY * skipDecay; |
718 |
Gear^.dX := Gear^.dX * skipDecay; |
|
719 |
CheckGearDrowning := false; |
|
720 |
end |
|
10354 | 721 |
else // not skipping |
6581 | 722 |
begin |
10363 | 723 |
isImpact:= true; |
724 |
isSkip:= false; |
|
6581 | 725 |
if not isSubmersible then |
726 |
begin |
|
727 |
CheckGearDrowning := true; |
|
728 |
Gear^.State := gstDrowning; |
|
12177
bfeeb1c35e77
Set turn time to 0 when current hog drowns
Wuzzy <almikes@aol.com>
parents:
12176
diff
changeset
|
729 |
if Gear = CurrentHedgehog^.Gear then |
bfeeb1c35e77
Set turn time to 0 when current hog drowns
Wuzzy <almikes@aol.com>
parents:
12176
diff
changeset
|
730 |
TurnTimeLeft := 0; |
6581 | 731 |
Gear^.RenderTimer := false; |
732 |
if (Gear^.Kind <> gtSniperRifleShot) and (Gear^.Kind <> gtShotgunShot) |
|
12898 | 733 |
and (Gear^.Kind <> gtDEagleShot) and (Gear^.Kind <> gtSineGunShot) |
734 |
and (Gear^.Kind <> gtMinigunBullet) then |
|
6581 | 735 |
if Gear^.Kind = gtHedgehog then |
736 |
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:
6990
diff
changeset
|
737 |
if Gear^.Hedgehog^.Effects[heResurrectable] <> 0 then |
8947
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8763
diff
changeset
|
738 |
begin |
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8763
diff
changeset
|
739 |
// Gear could become nil after this, just exit to skip splashes |
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8763
diff
changeset
|
740 |
ResurrectHedgehog(Gear); |
10245 | 741 |
exit(true) |
8947
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8763
diff
changeset
|
742 |
end |
6581 | 743 |
else |
744 |
begin |
|
10354 | 745 |
DrownGear(Gear); |
6581 | 746 |
Gear^.State := Gear^.State and (not gstHHDriven); |
10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10116
diff
changeset
|
747 |
s:= ansistring(Gear^.Hedgehog^.Name); |
12169
869cf5f34700
More ticker messages: Sick, king died, resurrect, time box return, timeout, kamikaze
Wuzzy <almikes@aol.com>
parents:
12150
diff
changeset
|
748 |
if Gear^.Hedgehog^.King then |
13642
3d14950641a4
Refactor text color variable names, export 2 color values to Lua
Wuzzy <Wuzzy2@mail.ru>
parents:
13629
diff
changeset
|
749 |
AddCaption(FormatA(GetEventString(eidKingDied), s), capcolDefault, capgrpMessage) |
12169
869cf5f34700
More ticker messages: Sick, king died, resurrect, time box return, timeout, kamikaze
Wuzzy <almikes@aol.com>
parents:
12150
diff
changeset
|
750 |
else |
13642
3d14950641a4
Refactor text color variable names, export 2 color values to Lua
Wuzzy <Wuzzy2@mail.ru>
parents:
13629
diff
changeset
|
751 |
AddCaption(FormatA(GetEventString(eidDrowned), s), capcolDefault, capgrpMessage); |
6581 | 752 |
end |
753 |
end |
|
754 |
else |
|
10354 | 755 |
DrownGear(Gear); |
10419 | 756 |
if Gear^.Kind = gtFlake then |
10354 | 757 |
exit(true); // skip splashes |
8990 | 758 |
end |
10363 | 759 |
else // submersible |
760 |
begin |
|
14555
c38dd843763f
Fix double water splash if flying saucer drowns (bug 681)
Wuzzy <Wuzzy2@mail.ru>
parents:
14535
diff
changeset
|
761 |
// drown submersible gears if far below map |
10363 | 762 |
if (Y > cWaterLine + cVisibleWater*4) then |
763 |
begin |
|
764 |
DrownGear(Gear); |
|
765 |
exit(true); // no splashes needed |
|
766 |
end; |
|
10354 | 767 |
|
10363 | 768 |
CheckGearDrowning := false; |
769 |
||
770 |
// check if surface was penetrated |
|
10354 | 771 |
|
10363 | 772 |
// no penetration if center's water distance not smaller than radius |
12446
48ee3777e42e
trying to eliminate that annoying impact sound for gears that are well under the water and not even exiting it. sheepluva might want to look this over since this is modifying his code and should perhaps be part of the addSplashForGear checks, but hadn't had much luck getting him to examine it past year or so
nemo
parents:
12445
diff
changeset
|
773 |
if ((dist2Water + Gear^.Radius div 2) < 0) or (abs(dist2Water + Gear^.Radius) >= Gear^.Radius) then |
10363 | 774 |
isImpact:= false |
6804 | 775 |
else |
10354 | 776 |
begin |
10363 | 777 |
// get distance to water of last tick |
778 |
if isDirH then |
|
779 |
begin |
|
780 |
tmp:= hwRound(Gear^.X - Gear^.dX); |
|
12600 | 781 |
if abs(tmp - real(leftX)) < abs(tmp - real(rightX)) then // left edge |
782 |
isImpact:= (abs(tmp-real(leftX)) >= Gear^.Radius) and (Gear^.dX.isNegative) |
|
12446
48ee3777e42e
trying to eliminate that annoying impact sound for gears that are well under the water and not even exiting it. sheepluva might want to look this over since this is modifying his code and should perhaps be part of the addSplashForGear checks, but hadn't had much luck getting him to examine it past year or so
nemo
parents:
12445
diff
changeset
|
783 |
else |
12600 | 784 |
isImpact:= (abs(tmp-real(rightX)) >= Gear^.Radius) and (not Gear^.dX.isNegative); |
10363 | 785 |
end |
10354 | 786 |
else |
6803
0e70f3ea3bf8
bit of an experiment in variable splash sizes based on object/speed. not sure if it looks good yet. need to drown more stuff.
nemo
parents:
6769
diff
changeset
|
787 |
begin |
10363 | 788 |
tmp:= hwRound(Gear^.Y - Gear^.dY); |
789 |
tmp:= abs(cWaterLine - tmp); |
|
12446
48ee3777e42e
trying to eliminate that annoying impact sound for gears that are well under the water and not even exiting it. sheepluva might want to look this over since this is modifying his code and should perhaps be part of the addSplashForGear checks, but hadn't had much luck getting him to examine it past year or so
nemo
parents:
12445
diff
changeset
|
790 |
// there was an impact if distance was >= radius |
48ee3777e42e
trying to eliminate that annoying impact sound for gears that are well under the water and not even exiting it. sheepluva might want to look this over since this is modifying his code and should perhaps be part of the addSplashForGear checks, but hadn't had much luck getting him to examine it past year or so
nemo
parents:
12445
diff
changeset
|
791 |
isImpact:= (tmp >= Gear^.Radius) and (not Gear^.dY.isNegative); |
10363 | 792 |
end; |
10354 | 793 |
|
10363 | 794 |
end; |
795 |
end; // end of submersible |
|
796 |
end; // end of not skipping |
|
797 |
||
798 |
// splash sound animation and droplets |
|
799 |
if isImpact or isSkip then |
|
14555
c38dd843763f
Fix double water splash if flying saucer drowns (bug 681)
Wuzzy <Wuzzy2@mail.ru>
parents:
14535
diff
changeset
|
800 |
if (not (((dist2Water + Gear^.Radius div 2) < 0) or (abs(dist2Water + Gear^.Radius) >= Gear^.Radius))) then |
c38dd843763f
Fix double water splash if flying saucer drowns (bug 681)
Wuzzy <Wuzzy2@mail.ru>
parents:
14535
diff
changeset
|
801 |
addSplashForGear(Gear, isSkip); |
10363 | 802 |
|
10668 | 803 |
if isSkip then |
804 |
ScriptCall('onGearWaterSkip', Gear^.uid); |
|
6581 | 805 |
end |
806 |
else |
|
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
807 |
CheckGearDrowning := false |
6581 | 808 |
end; |
809 |
||
810 |
||
8947
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8763
diff
changeset
|
811 |
procedure ResurrectHedgehog(var gear: PGear); |
6581 | 812 |
var tempTeam : PTeam; |
13629
c9a49d06f1a2
Report spawning visual gear in onGearResurrect
Wuzzy <Wuzzy2@mail.ru>
parents:
13627
diff
changeset
|
813 |
sparkles, expl: PVisualGear; |
7092
c9ca770fd7fc
Add an emergency return to the timebox in the case of death of rest of team. Also add a small visual effect to AI survival
nemo
parents:
7066
diff
changeset
|
814 |
gX, gY: LongInt; |
6581 | 815 |
begin |
7357
06454899d0d2
Score AI resurrection as a kill. These values will not be the same as the in-game scoring, since in-game scoring doesn't count friendlies.
nemo
parents:
7272
diff
changeset
|
816 |
if (Gear^.LastDamage <> nil) then |
06454899d0d2
Score AI resurrection as a kill. These values will not be the same as the in-game scoring, since in-game scoring doesn't count friendlies.
nemo
parents:
7272
diff
changeset
|
817 |
uStats.HedgehogDamaged(Gear, Gear^.LastDamage, 0, true) |
06454899d0d2
Score AI resurrection as a kill. These values will not be the same as the in-game scoring, since in-game scoring doesn't count friendlies.
nemo
parents:
7272
diff
changeset
|
818 |
else |
06454899d0d2
Score AI resurrection as a kill. These values will not be the same as the in-game scoring, since in-game scoring doesn't count friendlies.
nemo
parents:
7272
diff
changeset
|
819 |
uStats.HedgehogDamaged(Gear, CurrentHedgehog, 0, true); |
13629
c9a49d06f1a2
Report spawning visual gear in onGearResurrect
Wuzzy <Wuzzy2@mail.ru>
parents:
13627
diff
changeset
|
820 |
// Reset gear state |
6581 | 821 |
AttackBar:= 0; |
822 |
gear^.dX := _0; |
|
823 |
gear^.dY := _0; |
|
824 |
gear^.Damage := 0; |
|
825 |
gear^.Health := gear^.Hedgehog^.InitialHealth; |
|
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:
6990
diff
changeset
|
826 |
gear^.Hedgehog^.Effects[hePoisoned] := 0; |
7176
fb4b0c6dfdbd
Make watching AI v AI on ai survival a bit more entertaining
nemo
parents:
7168
diff
changeset
|
827 |
if (CurrentHedgehog^.Effects[heResurrectable] = 0) or ((CurrentHedgehog^.Effects[heResurrectable] <> 0) |
fb4b0c6dfdbd
Make watching AI v AI on ai survival a bit more entertaining
nemo
parents:
7168
diff
changeset
|
828 |
and (Gear^.Hedgehog^.Team^.Clan <> CurrentHedgehog^.Team^.Clan)) then |
8330 | 829 |
with CurrentHedgehog^ do |
6581 | 830 |
begin |
831 |
inc(Team^.stats.AIKills); |
|
10634
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10558
diff
changeset
|
832 |
FreeAndNilTexture(Team^.AIKillsTex); |
10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10116
diff
changeset
|
833 |
Team^.AIKillsTex := RenderStringTex(ansistring(inttostr(Team^.stats.AIKills)), Team^.Clan^.Color, fnt16); |
6581 | 834 |
end; |
835 |
tempTeam := gear^.Hedgehog^.Team; |
|
836 |
DeleteCI(gear); |
|
7092
c9ca770fd7fc
Add an emergency return to the timebox in the case of death of rest of team. Also add a small visual effect to AI survival
nemo
parents:
7066
diff
changeset
|
837 |
gX := hwRound(gear^.X); |
c9ca770fd7fc
Add an emergency return to the timebox in the case of death of rest of team. Also add a small visual effect to AI survival
nemo
parents:
7066
diff
changeset
|
838 |
gY := hwRound(gear^.Y); |
13629
c9a49d06f1a2
Report spawning visual gear in onGearResurrect
Wuzzy <Wuzzy2@mail.ru>
parents:
13627
diff
changeset
|
839 |
// Spawn a few sparkles at death position. |
c9a49d06f1a2
Report spawning visual gear in onGearResurrect
Wuzzy <Wuzzy2@mail.ru>
parents:
13627
diff
changeset
|
840 |
// Might need more sparkles for a column. |
7092
c9ca770fd7fc
Add an emergency return to the timebox in the case of death of rest of team. Also add a small visual effect to AI survival
nemo
parents:
7066
diff
changeset
|
841 |
sparkles:= AddVisualGear(gX, gY, vgtDust, 1); |
c9ca770fd7fc
Add an emergency return to the timebox in the case of death of rest of team. Also add a small visual effect to AI survival
nemo
parents:
7066
diff
changeset
|
842 |
if sparkles <> nil then |
c9ca770fd7fc
Add an emergency return to the timebox in the case of death of rest of team. Also add a small visual effect to AI survival
nemo
parents:
7066
diff
changeset
|
843 |
begin |
c9ca770fd7fc
Add an emergency return to the timebox in the case of death of rest of team. Also add a small visual effect to AI survival
nemo
parents:
7066
diff
changeset
|
844 |
sparkles^.Tint:= tempTeam^.Clan^.Color shl 8 or $FF; |
c9ca770fd7fc
Add an emergency return to the timebox in the case of death of rest of team. Also add a small visual effect to AI survival
nemo
parents:
7066
diff
changeset
|
845 |
end; |
13629
c9a49d06f1a2
Report spawning visual gear in onGearResurrect
Wuzzy <Wuzzy2@mail.ru>
parents:
13627
diff
changeset
|
846 |
// Set new position of gear (might fail) |
8330 | 847 |
FindPlace(gear, false, 0, LAND_WIDTH, true); |
6581 | 848 |
if gear <> nil then |
849 |
begin |
|
13629
c9a49d06f1a2
Report spawning visual gear in onGearResurrect
Wuzzy <Wuzzy2@mail.ru>
parents:
13627
diff
changeset
|
850 |
// Visual effect at position of resurrection |
c9a49d06f1a2
Report spawning visual gear in onGearResurrect
Wuzzy <Wuzzy2@mail.ru>
parents:
13627
diff
changeset
|
851 |
expl:= AddVisualGear(hwRound(gear^.X), hwRound(gear^.Y), vgtExplosion); |
7168
8defaabce92e
warp sound when AI survival hog respawns. attempt at a bit of a crate spawn animation (moar sparkles and a quick fadein)
nemo
parents:
7092
diff
changeset
|
852 |
PlaySound(sndWarp); |
6581 | 853 |
RenderHealth(gear^.Hedgehog^); |
13629
c9a49d06f1a2
Report spawning visual gear in onGearResurrect
Wuzzy <Wuzzy2@mail.ru>
parents:
13627
diff
changeset
|
854 |
if expl <> nil then |
c9a49d06f1a2
Report spawning visual gear in onGearResurrect
Wuzzy <Wuzzy2@mail.ru>
parents:
13627
diff
changeset
|
855 |
ScriptCall('onGearResurrect', gear^.uid, expl^.uid) |
c9a49d06f1a2
Report spawning visual gear in onGearResurrect
Wuzzy <Wuzzy2@mail.ru>
parents:
13627
diff
changeset
|
856 |
else |
c9a49d06f1a2
Report spawning visual gear in onGearResurrect
Wuzzy <Wuzzy2@mail.ru>
parents:
13627
diff
changeset
|
857 |
ScriptCall('onGearResurrect', gear^.uid); |
6581 | 858 |
gear^.State := gstWait; |
8947
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8763
diff
changeset
|
859 |
end; |
6581 | 860 |
RecountTeamHealth(tempTeam); |
861 |
end; |
|
862 |
||
12448
8b89fe2115ad
So, was trying to allow spawning on level surfaces of ice but not girders, but seems to be failing. We'll call this WIP
nemo
parents:
12446
diff
changeset
|
863 |
function CountLand(x, y, r, c: LongInt; mask, antimask: LongWord): LongInt; |
6581 | 864 |
var i: LongInt; |
865 |
count: LongInt = 0; |
|
866 |
begin |
|
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset
|
867 |
if (y and LAND_HEIGHT_MASK) = 0 then |
10272
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
868 |
for i:= max(x - r, 0) to min(x + r, LAND_WIDTH - 1) do |
12448
8b89fe2115ad
So, was trying to allow spawning on level surfaces of ice but not girders, but seems to be failing. We'll call this WIP
nemo
parents:
12446
diff
changeset
|
869 |
if (Land[y, i] and mask <> 0) and (Land[y, i] and antimask = 0) then |
8b89fe2115ad
So, was trying to allow spawning on level surfaces of ice but not girders, but seems to be failing. We'll call this WIP
nemo
parents:
12446
diff
changeset
|
870 |
begin |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset
|
871 |
inc(count); |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset
|
872 |
if count = c then |
12448
8b89fe2115ad
So, was trying to allow spawning on level surfaces of ice but not girders, but seems to be failing. We'll call this WIP
nemo
parents:
12446
diff
changeset
|
873 |
begin |
8b89fe2115ad
So, was trying to allow spawning on level surfaces of ice but not girders, but seems to be failing. We'll call this WIP
nemo
parents:
12446
diff
changeset
|
874 |
CountLand:= count; |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset
|
875 |
exit |
12448
8b89fe2115ad
So, was trying to allow spawning on level surfaces of ice but not girders, but seems to be failing. We'll call this WIP
nemo
parents:
12446
diff
changeset
|
876 |
end; |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset
|
877 |
end; |
12448
8b89fe2115ad
So, was trying to allow spawning on level surfaces of ice but not girders, but seems to be failing. We'll call this WIP
nemo
parents:
12446
diff
changeset
|
878 |
CountLand:= count; |
6581 | 879 |
end; |
880 |
||
10272
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
881 |
function isSteadyPosition(x, y, r, c: LongInt; mask: Longword): boolean; |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
882 |
var cnt, i: LongInt; |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
883 |
begin |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
884 |
cnt:= 0; |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
885 |
isSteadyPosition:= false; |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
886 |
|
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
887 |
if ((y and LAND_HEIGHT_MASK) = 0) and (x - r >= 0) and (x + r < LAND_WIDTH) then |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
888 |
begin |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
889 |
for i:= r - c + 2 to r do |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
890 |
begin |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
891 |
if (Land[y, x - i] and mask <> 0) then inc(cnt); |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
892 |
if (Land[y, x + i] and mask <> 0) then inc(cnt); |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
893 |
|
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
894 |
if cnt >= c then |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
895 |
begin |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
896 |
isSteadyPosition:= true; |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
897 |
exit |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
898 |
end; |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
899 |
end; |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
900 |
end; |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
901 |
end; |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
902 |
|
6888 | 903 |
|
904 |
function NoGearsToAvoid(mX, mY: LongInt; rX, rY: LongInt): boolean; |
|
905 |
var t: PGear; |
|
906 |
begin |
|
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset
|
907 |
NoGearsToAvoid:= false; |
6888 | 908 |
t:= GearsList; |
909 |
rX:= sqr(rX); |
|
910 |
rY:= sqr(rY); |
|
911 |
while t <> nil do |
|
912 |
begin |
|
913 |
if t^.Kind <= gtExplosives then |
|
914 |
if not (hwSqr(int2hwFloat(mX) - t^.X) / rX + hwSqr(int2hwFloat(mY) - t^.Y) / rY > _1) then |
|
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6986
diff
changeset
|
915 |
exit; |
6888 | 916 |
t:= t^.NextGear |
917 |
end; |
|
918 |
NoGearsToAvoid:= true |
|
919 |
end; |
|
920 |
||
6986
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6888
diff
changeset
|
921 |
procedure FindPlace(var Gear: PGear; withFall: boolean; Left, Right: LongInt); inline; |
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6888
diff
changeset
|
922 |
begin |
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6888
diff
changeset
|
923 |
FindPlace(Gear, withFall, Left, Right, false); |
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6888
diff
changeset
|
924 |
end; |
6888 | 925 |
|
6581 | 926 |
procedure FindPlace(var Gear: PGear; withFall: boolean; Left, Right: LongInt; skipProximity: boolean); |
927 |
var x: LongInt; |
|
11193
283b6e6cf7ea
Scan from right too. Not sure this is actually helpful, so committing separately.
nemo
parents:
11192
diff
changeset
|
928 |
y, sy, dir: LongInt; |
8007 | 929 |
ar: array[0..1023] of TPoint; |
930 |
ar2: array[0..2047] of TPoint; |
|
8026
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
8007
diff
changeset
|
931 |
temp: TPoint; |
6581 | 932 |
cnt, cnt2: Longword; |
933 |
delta: LongInt; |
|
7190
aa8d68817c32
Make it AI survival almost definitely impossible by adding a 3rd pass to FindGear. 1st pass normal, 2nd pass allow close to objects, 3rd pass, allow overlapping objects.
nemo
parents:
7176
diff
changeset
|
934 |
ignoreNearObjects, ignoreOverlap, tryAgain: boolean; |
6581 | 935 |
begin |
7190
aa8d68817c32
Make it AI survival almost definitely impossible by adding a 3rd pass to FindGear. 1st pass normal, 2nd pass allow close to objects, 3rd pass, allow overlapping objects.
nemo
parents:
7176
diff
changeset
|
936 |
ignoreNearObjects:= false; // try not skipping proximity at first |
aa8d68817c32
Make it AI survival almost definitely impossible by adding a 3rd pass to FindGear. 1st pass normal, 2nd pass allow close to objects, 3rd pass, allow overlapping objects.
nemo
parents:
7176
diff
changeset
|
937 |
ignoreOverlap:= false; // this not only skips proximity, but allows overlapping objects (barrels, mines, hogs, crates). Saving it for a 3rd pass. With this active, winning AI Survival goes back to virtual impossibility |
6581 | 938 |
tryAgain:= true; |
10015 | 939 |
if WorldEdge <> weNone then |
9477 | 940 |
begin |
14303
6015b74eea55
overall, using LongInt for leftX/rightX results in fewer casts, since most comparisons are against ints.
nemo
parents:
14224
diff
changeset
|
941 |
Left:= max(Left, leftX + Gear^.Radius); |
9477 | 942 |
Right:= min(Right,rightX-Gear^.Radius) |
943 |
end; |
|
6581 | 944 |
while tryAgain do |
945 |
begin |
|
8007 | 946 |
delta:= LAND_WIDTH div 16; |
6581 | 947 |
cnt2:= 0; |
948 |
repeat |
|
11193
283b6e6cf7ea
Scan from right too. Not sure this is actually helpful, so committing separately.
nemo
parents:
11192
diff
changeset
|
949 |
if GetRandom(2) = 0 then dir:= -1 else dir:= 1; |
283b6e6cf7ea
Scan from right too. Not sure this is actually helpful, so committing separately.
nemo
parents:
11192
diff
changeset
|
950 |
x:= max(LAND_WIDTH div 2048, LongInt(GetRandom(Delta))); |
283b6e6cf7ea
Scan from right too. Not sure this is actually helpful, so committing separately.
nemo
parents:
11192
diff
changeset
|
951 |
if dir = 1 then x:= Left + x else x:= Right - x; |
6581 | 952 |
repeat |
953 |
cnt:= 0; |
|
9809 | 954 |
y:= min(1024, topY) - Gear^.Radius shl 1; |
6581 | 955 |
while y < cWaterLine do |
956 |
begin |
|
957 |
repeat |
|
958 |
inc(y, 2); |
|
7190
aa8d68817c32
Make it AI survival almost definitely impossible by adding a 3rd pass to FindGear. 1st pass normal, 2nd pass allow close to objects, 3rd pass, allow overlapping objects.
nemo
parents:
7176
diff
changeset
|
959 |
until (y >= cWaterLine) or |
12448
8b89fe2115ad
So, was trying to allow spawning on level surfaces of ice but not girders, but seems to be failing. We'll call this WIP
nemo
parents:
12446
diff
changeset
|
960 |
(ignoreOverLap and (CountLand(x, y, Gear^.Radius - 1, 1, $FF00, 0) = 0)) or |
8b89fe2115ad
So, was trying to allow spawning on level surfaces of ice but not girders, but seems to be failing. We'll call this WIP
nemo
parents:
12446
diff
changeset
|
961 |
(not ignoreOverLap and (CountLand(x, y, Gear^.Radius - 1, 1, $FFFF, 0) = 0)); |
8b89fe2115ad
So, was trying to allow spawning on level surfaces of ice but not girders, but seems to be failing. We'll call this WIP
nemo
parents:
12446
diff
changeset
|
962 |
|
6581 | 963 |
|
964 |
sy:= y; |
|
965 |
||
966 |
repeat |
|
967 |
inc(y); |
|
7190
aa8d68817c32
Make it AI survival almost definitely impossible by adding a 3rd pass to FindGear. 1st pass normal, 2nd pass allow close to objects, 3rd pass, allow overlapping objects.
nemo
parents:
7176
diff
changeset
|
968 |
until (y >= cWaterLine) or |
12448
8b89fe2115ad
So, was trying to allow spawning on level surfaces of ice but not girders, but seems to be failing. We'll call this WIP
nemo
parents:
12446
diff
changeset
|
969 |
(ignoreOverlap and |
12449 | 970 |
(CountLand(x, y, Gear^.Radius - 1, 1, $FFFF, 0) <> 0)) or |
12448
8b89fe2115ad
So, was trying to allow spawning on level surfaces of ice but not girders, but seems to be failing. We'll call this WIP
nemo
parents:
12446
diff
changeset
|
971 |
(not ignoreOverlap and |
12449 | 972 |
(CountLand(x, y, Gear^.Radius - 1, 1, lfLandMask, 0) <> 0)); |
6581 | 973 |
|
10272
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
974 |
if (y - sy > Gear^.Radius * 2) and (y < cWaterLine) |
6581 | 975 |
and (((Gear^.Kind = gtExplosives) |
10272
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
976 |
and (ignoreNearObjects or NoGearsToAvoid(x, y - Gear^.Radius, 60, 60)) |
10274 | 977 |
and (isSteadyPosition(x, y+1, Gear^.Radius - 1, 3, $FFFF) |
12448
8b89fe2115ad
So, was trying to allow spawning on level surfaces of ice but not girders, but seems to be failing. We'll call this WIP
nemo
parents:
12446
diff
changeset
|
978 |
or (CountLand(x, y+1, Gear^.Radius - 1, Gear^.Radius+1, $FFFF, 0) > Gear^.Radius) |
10274 | 979 |
)) |
10272
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
980 |
or |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
981 |
((Gear^.Kind <> gtExplosives) |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
982 |
and (ignoreNearObjects or NoGearsToAvoid(x, y - Gear^.Radius, 110, 110)) |
12449 | 983 |
and (isSteadyPosition(x, y+1, Gear^.Radius - 1, 3, lfIce) |
984 |
or (CountLand(x, y+1, Gear^.Radius - 1, Gear^.Radius+1, $FFFF, lfIce) <> 0) |
|
985 |
))) then |
|
6888 | 986 |
begin |
6581 | 987 |
ar[cnt].X:= x; |
988 |
if withFall then |
|
989 |
ar[cnt].Y:= sy + Gear^.Radius |
|
990 |
else |
|
991 |
ar[cnt].Y:= y - Gear^.Radius; |
|
992 |
inc(cnt) |
|
993 |
end; |
|
994 |
||
7603
e9c3c67b5dfd
reducing this value is sufficient to ensure crates drop just below top border or a girder
nemo
parents:
7599
diff
changeset
|
995 |
inc(y, 10) |
6581 | 996 |
end; |
997 |
||
998 |
if cnt > 0 then |
|
10015 | 999 |
begin |
1000 |
temp := ar[GetRandom(cnt)]; |
|
1001 |
with temp do |
|
6581 | 1002 |
begin |
1003 |
ar2[cnt2].x:= x; |
|
1004 |
ar2[cnt2].y:= y; |
|
1005 |
inc(cnt2) |
|
11193
283b6e6cf7ea
Scan from right too. Not sure this is actually helpful, so committing separately.
nemo
parents:
11192
diff
changeset
|
1006 |
end; |
11192
0f6916065849
This should probably fix feedback that hogs weren't spawning on left side of map.
nemo
parents:
11046
diff
changeset
|
1007 |
end; |
11193
283b6e6cf7ea
Scan from right too. Not sure this is actually helpful, so committing separately.
nemo
parents:
11192
diff
changeset
|
1008 |
inc(x, Delta*dir) |
283b6e6cf7ea
Scan from right too. Not sure this is actually helpful, so committing separately.
nemo
parents:
11192
diff
changeset
|
1009 |
until ((dir = 1) and (x > Right)) or ((dir = -1) and (x < Left)); |
6581 | 1010 |
|
1011 |
dec(Delta, 60) |
|
1012 |
until (cnt2 > 0) or (Delta < 70); |
|
7190
aa8d68817c32
Make it AI survival almost definitely impossible by adding a 3rd pass to FindGear. 1st pass normal, 2nd pass allow close to objects, 3rd pass, allow overlapping objects.
nemo
parents:
7176
diff
changeset
|
1013 |
// if either of these has not been tried, do another pass |
aa8d68817c32
Make it AI survival almost definitely impossible by adding a 3rd pass to FindGear. 1st pass normal, 2nd pass allow close to objects, 3rd pass, allow overlapping objects.
nemo
parents:
7176
diff
changeset
|
1014 |
if (cnt2 = 0) and skipProximity and (not ignoreOverlap) then |
6581 | 1015 |
tryAgain:= true |
1016 |
else tryAgain:= false; |
|
7190
aa8d68817c32
Make it AI survival almost definitely impossible by adding a 3rd pass to FindGear. 1st pass normal, 2nd pass allow close to objects, 3rd pass, allow overlapping objects.
nemo
parents:
7176
diff
changeset
|
1017 |
if ignoreNearObjects then ignoreOverlap:= true; |
aa8d68817c32
Make it AI survival almost definitely impossible by adding a 3rd pass to FindGear. 1st pass normal, 2nd pass allow close to objects, 3rd pass, allow overlapping objects.
nemo
parents:
7176
diff
changeset
|
1018 |
ignoreNearObjects:= true; |
6581 | 1019 |
end; |
1020 |
||
1021 |
if cnt2 > 0 then |
|
8026
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
8007
diff
changeset
|
1022 |
begin |
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
8007
diff
changeset
|
1023 |
temp := ar2[GetRandom(cnt2)]; |
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
8007
diff
changeset
|
1024 |
with temp do |
6581 | 1025 |
begin |
1026 |
Gear^.X:= int2hwFloat(x); |
|
1027 |
Gear^.Y:= int2hwFloat(y); |
|
1028 |
AddFileLog('Assigned Gear coordinates (' + inttostr(x) + ',' + inttostr(y) + ')'); |
|
1029 |
end |
|
8026
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
8007
diff
changeset
|
1030 |
end |
11477
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1031 |
else |
6581 | 1032 |
begin |
1033 |
OutError('Can''t find place for Gear', false); |
|
1034 |
if Gear^.Kind = gtHedgehog then |
|
11477
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1035 |
begin |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1036 |
cnt:= 0; |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1037 |
if GameTicks = 0 then |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1038 |
begin |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1039 |
//AddFileLog('Trying to make a hole'); |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1040 |
while (cnt < 1000) do |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1041 |
begin |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1042 |
inc(cnt); |
11751
20e0a72e0e2c
make hog fallback (flower-in-hole) positioning respect limits (e.g. used by gfDivideTeams)
sheepluva
parents:
11551
diff
changeset
|
1043 |
x:= left+GetRandom(right-left-2*cHHRadius)+cHHRadius; |
11479 | 1044 |
y:= topY+GetRandom(LAND_HEIGHT-topY-64)+48; |
11478
8c95d5a4366c
Tweak the hole carving to become less agressive about spacing if random points keep failing.
nemo
parents:
11477
diff
changeset
|
1045 |
if NoGearsToAvoid(x, y, 100 div max(1,cnt div 100), 100 div max(1,cnt div 100)) then |
11477
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1046 |
begin |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1047 |
Gear^.State:= Gear^.State or gsttmpFlag; |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1048 |
Gear^.X:= int2hwFloat(x); |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1049 |
Gear^.Y:= int2hwFloat(y); |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1050 |
AddFileLog('Picked a spot for hog at coordinates (' + inttostr(hwRound(Gear^.X)) + ',' + inttostr(hwRound(Gear^.Y)) + ')'); |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1051 |
cnt:= 2000 |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1052 |
end |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1053 |
end; |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1054 |
end; |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1055 |
if cnt < 2000 then |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1056 |
begin |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1057 |
Gear^.Hedgehog^.Effects[heResurrectable] := 0; |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1058 |
DeleteGear(Gear); |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1059 |
Gear:= nil |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1060 |
end |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1061 |
end |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1062 |
else |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1063 |
begin |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1064 |
DeleteGear(Gear); |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1065 |
Gear:= nil |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11472
diff
changeset
|
1066 |
end |
6581 | 1067 |
end |
1068 |
end; |
|
1069 |
||
13920 | 1070 |
function CheckGearNearImpl(Kind: TGearType; X, Y: hwFloat; rX, rY: LongInt; exclude: PGear): PGear; |
13921 | 1071 |
var t: PGear; |
13922 | 1072 |
width, bound, dX, dY: hwFloat; |
13912 | 1073 |
isHit: Boolean; |
15202 | 1074 |
i, j: LongWord; |
6581 | 1075 |
begin |
13915 | 1076 |
bound:= _1_5 * int2hwFloat(max(rX, rY)); |
13912 | 1077 |
rX:= sqr(rX); |
1078 |
rY:= sqr(rY); |
|
13913 | 1079 |
width:= int2hwFloat(RightX - LeftX); |
15202 | 1080 |
if (Kind = gtHedgehog) then |
13399 | 1081 |
begin |
15202 | 1082 |
for j:= 0 to Pred(TeamsCount) do |
1083 |
if TeamsArray[j]^.TeamHealth > 0 then // it's impossible for a team to have hogs in game and zero health right? |
|
1084 |
with TeamsArray[j]^ do |
|
1085 |
for i:= 0 to cMaxHHIndex do |
|
1086 |
with Hedgehogs[i] do |
|
1087 |
if (Gear <> nil) and (Gear <> exclude) then |
|
1088 |
begin |
|
1089 |
// code duplication - could throw into an inline function I guess |
|
1090 |
dX := X - Gear^.X; |
|
1091 |
dY := Y - Gear^.Y; |
|
1092 |
isHit := (hwAbs(dX) + hwAbs(dY) < bound) |
|
1093 |
and (not ((hwSqr(dX) / rX + hwSqr(dY) / rY) > _1)); |
|
13912 | 1094 |
|
15202 | 1095 |
if (not isHit) and (WorldEdge = weWrap) then |
1096 |
begin |
|
1097 |
if (hwAbs(dX - width) + hwAbs(dY) < bound) |
|
1098 |
and (not ((hwSqr(dX - width) / rX + hwSqr(dY) / rY) > _1)) then |
|
1099 |
isHit := true |
|
1100 |
else if (hwAbs(dX + width) + hwAbs(dY) < bound) |
|
1101 |
and (not ((hwSqr(dX + width) / rX + hwSqr(dY) / rY) > _1)) then |
|
1102 |
isHit := true |
|
1103 |
end; |
|
1104 |
||
1105 |
if isHit then |
|
1106 |
begin |
|
1107 |
CheckGearNearImpl:= Gear; |
|
1108 |
exit; |
|
1109 |
end |
|
1110 |
end; |
|
1111 |
end |
|
1112 |
else |
|
1113 |
begin |
|
1114 |
t:= GearsList; |
|
1115 |
||
1116 |
while t <> nil do |
|
13912 | 1117 |
begin |
15202 | 1118 |
if (t <> exclude) and (t^.Kind = Kind) then |
1119 |
begin |
|
1120 |
dX := X - t^.X; |
|
1121 |
dY := Y - t^.Y; |
|
1122 |
isHit := (hwAbs(dX) + hwAbs(dY) < bound) |
|
1123 |
and (not ((hwSqr(dX) / rX + hwSqr(dY) / rY) > _1)); |
|
13912 | 1124 |
|
15202 | 1125 |
if (not isHit) and (WorldEdge = weWrap) then |
1126 |
begin |
|
1127 |
if (hwAbs(dX - width) + hwAbs(dY) < bound) |
|
1128 |
and (not ((hwSqr(dX - width) / rX + hwSqr(dY) / rY) > _1)) then |
|
1129 |
isHit := true |
|
1130 |
else if (hwAbs(dX + width) + hwAbs(dY) < bound) |
|
1131 |
and (not ((hwSqr(dX + width) / rX + hwSqr(dY) / rY) > _1)) then |
|
1132 |
isHit := true |
|
1133 |
end; |
|
1134 |
||
1135 |
if isHit then |
|
1136 |
begin |
|
1137 |
CheckGearNearImpl:= t; |
|
1138 |
exit; |
|
1139 |
end; |
|
1140 |
end; |
|
1141 |
t:= t^.NextGear |
|
1142 |
end |
|
13399 | 1143 |
end; |
1144 |
||
13922 | 1145 |
CheckGearNearImpl:= nil |
13912 | 1146 |
end; |
1147 |
||
1148 |
function CheckGearNear(Kind: TGearType; X, Y: hwFloat; rX, rY: LongInt): PGear; |
|
1149 |
begin |
|
1150 |
CheckGearNear := CheckGearNearImpl(Kind, X, Y, rX, rY, nil); |
|
13399 | 1151 |
end; |
1152 |
||
1153 |
function CheckGearNear(Gear: PGear; Kind: TGearType; rX, rY: LongInt): PGear; |
|
1154 |
begin |
|
13912 | 1155 |
CheckGearNear := CheckGearNearImpl(Kind, Gear^.X, Gear^.Y, rX, rY, Gear); |
6581 | 1156 |
end; |
1157 |
||
7592 | 1158 |
procedure CheckCollision(Gear: PGear); inline; |
1159 |
begin |
|
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
1160 |
if (TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) <> 0) |
7592 | 1161 |
or (TestCollisionYwithGear(Gear, hwSign(Gear^.dY)) <> 0) then |
1162 |
Gear^.State := Gear^.State or gstCollision |
|
1163 |
else |
|
1164 |
Gear^.State := Gear^.State and (not gstCollision) |
|
1165 |
end; |
|
1166 |
||
1167 |
procedure CheckCollisionWithLand(Gear: PGear); inline; |
|
1168 |
begin |
|
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
1169 |
if (TestCollisionX(Gear, hwSign(Gear^.dX)) <> 0) |
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
1170 |
or (TestCollisionY(Gear, hwSign(Gear^.dY)) <> 0) then |
7592 | 1171 |
Gear^.State := Gear^.State or gstCollision |
8330 | 1172 |
else |
7592 | 1173 |
Gear^.State := Gear^.State and (not gstCollision) |
1174 |
end; |
|
1175 |
||
7719
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1176 |
function MakeHedgehogsStep(Gear: PGear) : boolean; |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1177 |
begin |
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
1178 |
if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) <> 0 then if (TestCollisionYwithGear(Gear, -1) = 0) then |
7719
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1179 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1180 |
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
|
1181 |
if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) <> 0 then if (TestCollisionYwithGear(Gear, -1) = 0) then |
7719
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1182 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1183 |
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
|
1184 |
if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) <> 0 then if (TestCollisionYwithGear(Gear, -1) = 0) then |
7719
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1185 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1186 |
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
|
1187 |
if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) <> 0 then if (TestCollisionYwithGear(Gear, -1) = 0) then |
7719
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1188 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1189 |
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
|
1190 |
if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) <> 0 then if (TestCollisionYwithGear(Gear, -1) = 0) then |
7719
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1191 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1192 |
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
|
1193 |
if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) <> 0 then if (TestCollisionYwithGear(Gear, -1) = 0) then |
7719
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1194 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1195 |
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
|
1196 |
if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) <> 0 then |
7719
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1197 |
Gear^.Y:= Gear^.Y + _6 |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1198 |
end else Gear^.Y:= Gear^.Y + _5 else |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1199 |
end else Gear^.Y:= Gear^.Y + _4 else |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1200 |
end else Gear^.Y:= Gear^.Y + _3 else |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1201 |
end else Gear^.Y:= Gear^.Y + _2 else |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1202 |
end else Gear^.Y:= Gear^.Y + _1 |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1203 |
end; |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1204 |
|
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
1205 |
if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) = 0 then |
7719
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1206 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1207 |
Gear^.X:= Gear^.X + SignAs(_1, Gear^.dX); |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1208 |
MakeHedgehogsStep:= true |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1209 |
end else |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1210 |
MakeHedgehogsStep:= false; |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1211 |
|
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1212 |
if TestCollisionYwithGear(Gear, 1) = 0 then |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1213 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1214 |
Gear^.Y:= Gear^.Y + _1; |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1215 |
if TestCollisionYwithGear(Gear, 1) = 0 then |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1216 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1217 |
Gear^.Y:= Gear^.Y + _1; |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1218 |
if TestCollisionYwithGear(Gear, 1) = 0 then |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1219 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1220 |
Gear^.Y:= Gear^.Y + _1; |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1221 |
if TestCollisionYwithGear(Gear, 1) = 0 then |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1222 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1223 |
Gear^.Y:= Gear^.Y + _1; |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1224 |
if TestCollisionYwithGear(Gear, 1) = 0 then |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1225 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1226 |
Gear^.Y:= Gear^.Y + _1; |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1227 |
if TestCollisionYwithGear(Gear, 1) = 0 then |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1228 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1229 |
Gear^.Y:= Gear^.Y + _1; |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1230 |
if TestCollisionYwithGear(Gear, 1) = 0 then |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1231 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1232 |
Gear^.Y:= Gear^.Y - _6; |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1233 |
Gear^.dY:= _0; |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1234 |
Gear^.State:= Gear^.State or gstMoving; |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1235 |
exit |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1236 |
end; |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1237 |
end |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1238 |
end |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1239 |
end |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1240 |
end |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1241 |
end |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1242 |
end; |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1243 |
end; |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1244 |
|
9285 | 1245 |
|
1246 |
procedure ShotgunShot(Gear: PGear); |
|
1247 |
var t: PGear; |
|
1248 |
dmg, r, dist: LongInt; |
|
1249 |
dx, dy: hwFloat; |
|
1250 |
begin |
|
1251 |
Gear^.Radius:= cShotgunRadius; |
|
1252 |
t:= GearsList; |
|
1253 |
while t <> nil do |
|
1254 |
begin |
|
1255 |
case t^.Kind of |
|
1256 |
gtHedgehog, |
|
1257 |
gtMine, |
|
1258 |
gtSMine, |
|
13407
06792533ef91
ensure shotgun works with portals and make it hit airmines
alfadur
parents:
13403
diff
changeset
|
1259 |
gtAirMine, |
9285 | 1260 |
gtKnife, |
1261 |
gtCase, |
|
1262 |
gtTarget, |
|
14217
ab5e710d353d
Remove all traces of dead code related to amStructure/gtStructure
Wuzzy <Wuzzy2@mail.ru>
parents:
14062
diff
changeset
|
1263 |
gtExplosives: begin |
9285 | 1264 |
//addFileLog('ShotgunShot radius: ' + inttostr(Gear^.Radius) + ', t^.Radius = ' + inttostr(t^.Radius) + ', distance = ' + inttostr(dist) + ', dmg = ' + inttostr(dmg)); |
1265 |
dmg:= 0; |
|
1266 |
r:= Gear^.Radius + t^.Radius; |
|
1267 |
dx:= Gear^.X-t^.X; |
|
1268 |
dx.isNegative:= false; |
|
1269 |
dy:= Gear^.Y-t^.Y; |
|
1270 |
dy.isNegative:= false; |
|
1271 |
if r-hwRound(dx+dy) > 0 then |
|
1272 |
begin |
|
1273 |
dist:= hwRound(Distance(dx, dy)); |
|
11472 | 1274 |
dmg:= ModifyDamage(min(r - dist, Gear^.Boom), t); |
9285 | 1275 |
end; |
1276 |
if dmg > 0 then |
|
1277 |
begin |
|
10558 | 1278 |
if (t^.Kind <> gtHedgehog) or (t^.Hedgehog^.Effects[heInvulnerable] = 0) then |
9285 | 1279 |
ApplyDamage(t, Gear^.Hedgehog, dmg, dsBullet) |
1280 |
else |
|
1281 |
Gear^.State:= Gear^.State or gstWinner; |
|
1282 |
||
1283 |
DeleteCI(t); |
|
1284 |
t^.dX:= t^.dX + Gear^.dX * dmg * _0_01 + SignAs(cHHKick, Gear^.dX); |
|
1285 |
t^.dY:= t^.dY + Gear^.dY * dmg * _0_01; |
|
1286 |
t^.State:= t^.State or gstMoving; |
|
1287 |
if t^.Kind = gtKnife then t^.State:= t^.State and (not gstCollision); |
|
1288 |
t^.Active:= true; |
|
14221 | 1289 |
FollowGear:= t; |
1290 |
||
1291 |
if t^.Kind = gtAirmine then |
|
1292 |
begin |
|
1293 |
t^.Tag:= 1; |
|
1294 |
t^.FlightTime:= 5000; |
|
1295 |
end |
|
9285 | 1296 |
end |
1297 |
end; |
|
1298 |
gtGrave: begin |
|
1299 |
dmg:= 0; |
|
1300 |
r:= Gear^.Radius + t^.Radius; |
|
1301 |
dx:= Gear^.X-t^.X; |
|
1302 |
dx.isNegative:= false; |
|
1303 |
dy:= Gear^.Y-t^.Y; |
|
1304 |
dy.isNegative:= false; |
|
1305 |
if r-hwRound(dx+dy) > 0 then |
|
1306 |
begin |
|
1307 |
dist:= hwRound(Distance(dx, dy)); |
|
11472 | 1308 |
dmg:= ModifyDamage(min(r - dist, Gear^.Boom), t); |
9285 | 1309 |
end; |
1310 |
if dmg > 0 then |
|
1311 |
begin |
|
1312 |
t^.dY:= - _0_1; |
|
1313 |
t^.Active:= true |
|
1314 |
end |
|
1315 |
end; |
|
1316 |
end; |
|
1317 |
t:= t^.NextGear |
|
1318 |
end; |
|
1319 |
if (GameFlags and gfSolidLand) = 0 then |
|
1320 |
DrawExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), cShotgunRadius) |
|
1321 |
end; |
|
1322 |
||
12712
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1323 |
// Returns true if the given hog gear can use the tardis |
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1324 |
function CanUseTardis(HHGear: PGear): boolean; |
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1325 |
var usable: boolean; |
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1326 |
i, j, cnt: LongInt; |
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1327 |
HH: PHedgehog; |
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1328 |
begin |
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1329 |
(* |
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1330 |
Conditions for not activating. |
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1331 |
1. Hog is last of his clan |
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1332 |
2. Sudden Death is in play |
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1333 |
3. Hog is a king |
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1334 |
*) |
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1335 |
usable:= true; |
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1336 |
HH:= HHGear^.Hedgehog; |
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1337 |
if HHGear <> nil then |
12920
21827fc9ca98
Fix timebox being usable in SD w/ damage=0
Wuzzy <Wuzzy2@mail.ru>
parents:
12898
diff
changeset
|
1338 |
if (HHGear = nil) or (HH^.King) or (SuddenDeathActive) then |
12712
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1339 |
usable:= false; |
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1340 |
cnt:= 0; |
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1341 |
for j:= 0 to Pred(HH^.Team^.Clan^.TeamsNumber) do |
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1342 |
for i:= 0 to Pred(HH^.Team^.Clan^.Teams[j]^.HedgehogsNumber) do |
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1343 |
if (HH^.Team^.Clan^.Teams[j]^.Hedgehogs[i].Gear <> nil) |
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1344 |
and ((HH^.Team^.Clan^.Teams[j]^.Hedgehogs[i].Gear^.State and gstDrowning) = 0) |
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1345 |
and (HH^.Team^.Clan^.Teams[j]^.Hedgehogs[i].Gear^.Health > HH^.Team^.Clan^.Teams[j]^.Hedgehogs[i].Gear^.Damage) then |
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1346 |
inc(cnt); |
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1347 |
if (cnt < 2) then |
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1348 |
usable:= false; |
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1349 |
CanUseTardis:= usable; |
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1350 |
end; |
31f7e0a31736
AI player checks if it can use tardis before selecting it
Wuzzy <almikes@aol.com>
parents:
12656
diff
changeset
|
1351 |
|
12898 | 1352 |
procedure AmmoShoveImpl(Ammo: PGear; Damage, Power: LongInt; collisions: PGearArray); |
9285 | 1353 |
var t: PGearArray; |
1354 |
Gear: PGear; |
|
1355 |
i, j, tmpDmg: LongInt; |
|
1356 |
VGear: PVisualGear; |
|
1357 |
begin |
|
12898 | 1358 |
t:= collisions; |
1359 |
||
9285 | 1360 |
// Just to avoid hogs on rope dodging fire. |
1361 |
if (CurAmmoGear <> nil) and ((CurAmmoGear^.Kind = gtRope) or (CurAmmoGear^.Kind = gtJetpack) or (CurAmmoGear^.Kind = gtBirdy)) |
|
1362 |
and (CurrentHedgehog^.Gear <> nil) and (CurrentHedgehog^.Gear^.CollisionIndex = -1) |
|
1363 |
and (sqr(hwRound(Ammo^.X) - hwRound(CurrentHedgehog^.Gear^.X)) + sqr(hwRound(Ammo^.Y) - hwRound(CurrentHedgehog^.Gear^.Y)) <= sqr(cHHRadius + Ammo^.Radius)) then |
|
1364 |
begin |
|
1365 |
t^.ar[t^.Count]:= CurrentHedgehog^.Gear; |
|
1366 |
inc(t^.Count) |
|
1367 |
end; |
|
1368 |
||
1369 |
i:= t^.Count; |
|
1370 |
||
1371 |
if (Ammo^.Kind = gtFlame) and (i > 0) then |
|
1372 |
Ammo^.Health:= 0; |
|
1373 |
while i > 0 do |
|
1374 |
begin |
|
1375 |
dec(i); |
|
1376 |
Gear:= t^.ar[i]; |
|
14028 | 1377 |
if (Ammo^.Kind in [gtDEagleShot, gtSniperRifleShot, gtMinigunBullet, |
14358 | 1378 |
gtFirePunch, gtKamikaze, gtWhip, gtShover]) |
13403
9c9d29be9e00
make all bullets function similar to machinegun bullets (can hit/shove objects without checkin)
nemo
parents:
13399
diff
changeset
|
1379 |
and (((Ammo^.Data <> nil) and (PGear(Ammo^.Data) = Gear)) |
9c9d29be9e00
make all bullets function similar to machinegun bullets (can hit/shove objects without checkin)
nemo
parents:
13399
diff
changeset
|
1380 |
or (not UpdateHitOrder(Gear, Ammo^.WDTimer))) then |
11550
881231c1ba46
disallow bullets to hit the hedgehog that fired them (unless bounced/wrapped/portal'd)
sheepluva
parents:
11479
diff
changeset
|
1381 |
continue; |
12898 | 1382 |
|
10015 | 1383 |
if ((Ammo^.Kind = gtFlame) or (Ammo^.Kind = gtBlowTorch)) and |
12898 | 1384 |
(Gear^.Kind = gtHedgehog) and (Gear^.Hedgehog^.Effects[heFrozen] > 255) then |
9285 | 1385 |
Gear^.Hedgehog^.Effects[heFrozen]:= max(255,Gear^.Hedgehog^.Effects[heFrozen]-10000); |
1386 |
tmpDmg:= ModifyDamage(Damage, Gear); |
|
1387 |
if (Gear^.State and gstNoDamage) = 0 then |
|
1388 |
begin |
|
1389 |
||
1390 |
if (Gear^.Kind = gtHedgehog) and (Ammo^.State and gsttmpFlag <> 0) and (Ammo^.Kind = gtShover) then |
|
1391 |
Gear^.FlightTime:= 1; |
|
1392 |
||
1393 |
case Gear^.Kind of |
|
1394 |
gtHedgehog, |
|
1395 |
gtMine, |
|
13399 | 1396 |
gtAirMine, |
9285 | 1397 |
gtSMine, |
1398 |
gtKnife, |
|
1399 |
gtTarget, |
|
1400 |
gtCase, |
|
14217
ab5e710d353d
Remove all traces of dead code related to amStructure/gtStructure
Wuzzy <Wuzzy2@mail.ru>
parents:
14062
diff
changeset
|
1401 |
gtExplosives: |
9285 | 1402 |
begin |
14028 | 1403 |
if (Ammo^.Kind in [gtFirePunch, gtKamikaze]) and (Gear^.Kind <> gtSMine) then |
14020 | 1404 |
PlaySound(sndFirePunchHit); |
1405 |
||
13807 | 1406 |
if Ammo^.Kind in [gtDEagleShot, gtSniperRifleShot, gtMinigunBullet] then |
1407 |
begin |
|
1408 |
VGear := AddVisualGear(t^.cX[i], t^.cY[i], vgtBulletHit); |
|
1409 |
if VGear <> nil then |
|
1410 |
VGear^.Angle := DxDy2Angle(-Ammo^.dX, Ammo^.dY); |
|
1411 |
end; |
|
9285 | 1412 |
if (Ammo^.Kind = gtDrill) then |
1413 |
begin |
|
1414 |
Ammo^.Timer:= 0; |
|
1415 |
exit; |
|
1416 |
end; |
|
10011
ead5e4b21671
Add check for gear kind of hedgehog on invulnerability effect. This probably fixes bug #766, is similar to change in previous r2a1483d91977 and was introduced by r7d925e82e572
nemo
parents:
10010
diff
changeset
|
1417 |
if (Gear^.Kind <> gtHedgehog) or (Gear^.Hedgehog^.Effects[heInvulnerable] = 0) then |
9285 | 1418 |
begin |
1419 |
if (Ammo^.Kind = gtKnife) and (tmpDmg > 0) then |
|
1420 |
for j:= 1 to max(1,min(3,tmpDmg div 5)) do |
|
1421 |
begin |
|
12898 | 1422 |
VGear:= AddVisualGear( |
1423 |
t^.cX[i] - ((t^.cX[i] - hwround(Gear^.X)) div 2), |
|
1424 |
t^.cY[i] - ((t^.cY[i] - hwround(Gear^.Y)) div 2), |
|
1425 |
vgtStraightShot); |
|
9285 | 1426 |
if VGear <> nil then |
1427 |
with VGear^ do |
|
1428 |
begin |
|
1429 |
Tint:= $FFCC00FF; |
|
1430 |
Angle:= random(360); |
|
1431 |
dx:= 0.0005 * (random(100)); |
|
1432 |
dy:= 0.0005 * (random(100)); |
|
1433 |
if random(2) = 0 then |
|
1434 |
dx := -dx; |
|
1435 |
if random(2) = 0 then |
|
1436 |
dy := -dy; |
|
1437 |
FrameTicks:= 600+random(200); |
|
1438 |
State:= ord(sprStar) |
|
1439 |
end |
|
1440 |
end; |
|
14221 | 1441 |
ApplyDamage(Gear, Ammo^.Hedgehog, tmpDmg, dsShove); |
1442 |
||
1443 |
if Gear^.Kind = gtAirmine then |
|
1444 |
begin |
|
1445 |
Gear^.Tag:= 1; |
|
1446 |
Gear^.FlightTime:= 5000; |
|
1447 |
end |
|
9285 | 1448 |
end |
1449 |
else |
|
1450 |
Gear^.State:= Gear^.State or gstWinner; |
|
10015 | 1451 |
if (Gear^.Kind = gtExplosives) and (Ammo^.Kind = gtBlowtorch) then |
9285 | 1452 |
begin |
1453 |
if (Ammo^.Hedgehog^.Gear <> nil) then |
|
1454 |
Ammo^.Hedgehog^.Gear^.State:= Ammo^.Hedgehog^.Gear^.State and (not gstNotKickable); |
|
14061
128fbd36eee4
Stop using dsUnknown, replace with concrete damage sources
Wuzzy <Wuzzy2@mail.ru>
parents:
14043
diff
changeset
|
1455 |
ApplyDamage(Gear, Ammo^.Hedgehog, tmpDmg * 100, dsExplosion); // crank up damage for explosives + blowtorch |
9285 | 1456 |
end; |
1457 |
||
1458 |
if (Gear^.Kind = gtHedgehog) and (Gear^.Hedgehog^.King or (Gear^.Hedgehog^.Effects[heFrozen] > 0)) then |
|
1459 |
begin |
|
13803 | 1460 |
Gear^.dX:= Ammo^.dX * Power * _0_005; |
1461 |
Gear^.dY:= Ammo^.dY * Power * _0_005 |
|
9285 | 1462 |
end |
1463 |
else if ((Ammo^.Kind <> gtFlame) or (Gear^.Kind = gtHedgehog)) and (Power <> 0) then |
|
1464 |
begin |
|
13803 | 1465 |
Gear^.dX:= Ammo^.dX * Power * _0_01; |
1466 |
Gear^.dY:= Ammo^.dY * Power * _0_01 |
|
9285 | 1467 |
end; |
1468 |
||
1469 |
if (not isZero(Gear^.dX)) or (not isZero(Gear^.dY)) then |
|
1470 |
begin |
|
1471 |
Gear^.Active:= true; |
|
1472 |
DeleteCI(Gear); |
|
1473 |
Gear^.State:= Gear^.State or gstMoving; |
|
1474 |
if Gear^.Kind = gtKnife then Gear^.State:= Gear^.State and (not gstCollision); |
|
1475 |
// move the gear upwards a bit to throw it over tiny obstacles at start |
|
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
1476 |
if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) <> 0 then |
9285 | 1477 |
begin |
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
1478 |
if (TestCollisionXwithXYShift(Gear, _0, -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
|
1479 |
(TestCollisionYwithGear(Gear, -1) = 0) then |
9285 | 1480 |
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
|
1481 |
if (TestCollisionXwithXYShift(Gear, _0, -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
|
1482 |
(TestCollisionYwithGear(Gear, -1) = 0) then |
9285 | 1483 |
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
|
1484 |
if (TestCollisionXwithXYShift(Gear, _0, -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
|
1485 |
(TestCollisionYwithGear(Gear, -1) = 0) then |
9285 | 1486 |
Gear^.Y:= Gear^.Y - _1; |
1487 |
end |
|
1488 |
end; |
|
1489 |
||
1490 |
||
1491 |
if (Ammo^.Kind <> gtFlame) or ((Ammo^.State and gsttmpFlag) = 0) then |
|
1492 |
FollowGear:= Gear |
|
1493 |
end; |
|
1494 |
end |
|
1495 |
end; |
|
1496 |
end; |
|
1497 |
if i <> 0 then |
|
1498 |
SetAllToActive |
|
1499 |
end; |
|
1500 |
||
12898 | 1501 |
procedure AmmoShoveLine(Ammo: PGear; Damage, Power: LongInt; oX, oY, tX, tY: hwFloat); |
1502 |
var t: PGearArray; |
|
1503 |
begin |
|
13403
9c9d29be9e00
make all bullets function similar to machinegun bullets (can hit/shove objects without checkin)
nemo
parents:
13399
diff
changeset
|
1504 |
t:= CheckAllGearsLineCollision(Ammo, oX, oY, tX, tY); |
12898 | 1505 |
AmmoShoveImpl(Ammo, Damage, Power, t); |
1506 |
end; |
|
1507 |
||
1508 |
procedure AmmoShove(Ammo: PGear; Damage, Power: LongInt); |
|
1509 |
begin |
|
1510 |
AmmoShoveImpl(Ammo, Damage, Power, |
|
1511 |
CheckGearsCollision(Ammo)); |
|
1512 |
end; |
|
1513 |
||
14027
105793e575d6
make firepunch hit moving gears (airmines are not amused)
alfadur
parents:
14026
diff
changeset
|
1514 |
procedure AmmoShoveCache(Ammo: PGear; Damage, Power: LongInt); |
105793e575d6
make firepunch hit moving gears (airmines are not amused)
alfadur
parents:
14026
diff
changeset
|
1515 |
begin |
105793e575d6
make firepunch hit moving gears (airmines are not amused)
alfadur
parents:
14026
diff
changeset
|
1516 |
AmmoShoveImpl(Ammo, Damage, Power, |
105793e575d6
make firepunch hit moving gears (airmines are not amused)
alfadur
parents:
14026
diff
changeset
|
1517 |
CheckCacheCollision(Ammo)); |
105793e575d6
make firepunch hit moving gears (airmines are not amused)
alfadur
parents:
14026
diff
changeset
|
1518 |
end; |
9285 | 1519 |
|
1520 |
function CountGears(Kind: TGearType): Longword; |
|
1521 |
var t: PGear; |
|
1522 |
count: Longword = 0; |
|
1523 |
begin |
|
1524 |
||
1525 |
t:= GearsList; |
|
1526 |
while t <> nil do |
|
1527 |
begin |
|
1528 |
if t^.Kind = Kind then |
|
1529 |
inc(count); |
|
1530 |
t:= t^.NextGear |
|
1531 |
end; |
|
1532 |
CountGears:= count; |
|
1533 |
end; |
|
1534 |
||
1535 |
procedure SetAllToActive; |
|
1536 |
var t: PGear; |
|
1537 |
begin |
|
1538 |
AllInactive:= false; |
|
1539 |
t:= GearsList; |
|
1540 |
while t <> nil do |
|
1541 |
begin |
|
1542 |
t^.Active:= true; |
|
1543 |
t:= t^.NextGear |
|
1544 |
end |
|
1545 |
end; |
|
1546 |
||
1547 |
procedure SetAllHHToActive; inline; |
|
1548 |
begin |
|
1549 |
SetAllHHToActive(true) |
|
1550 |
end; |
|
1551 |
||
1552 |
||
1553 |
procedure SetAllHHToActive(Ice: boolean); |
|
1554 |
var t: PGear; |
|
1555 |
begin |
|
1556 |
AllInactive:= false; |
|
1557 |
t:= GearsList; |
|
1558 |
while t <> nil do |
|
1559 |
begin |
|
1560 |
if (t^.Kind = gtHedgehog) or (t^.Kind = gtExplosives) then |
|
1561 |
begin |
|
1562 |
if (t^.Kind = gtHedgehog) and Ice then CheckIce(t); |
|
1563 |
t^.Active:= true |
|
1564 |
end; |
|
1565 |
t:= t^.NextGear |
|
1566 |
end |
|
1567 |
end; |
|
1568 |
||
1569 |
||
1570 |
var GearsNearArray : TPGearArray; |
|
1571 |
function GearsNear(X, Y: hwFloat; Kind: TGearType; r: LongInt): PGearArrayS; |
|
1572 |
var |
|
1573 |
t: PGear; |
|
1574 |
s: Longword; |
|
12743
f45ffb4cf1e1
Make GearsNear and CheckGearNear check gears across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
12737
diff
changeset
|
1575 |
xc, xc_left, xc_right, yc: hwFloat; |
9285 | 1576 |
begin |
1577 |
r:= r*r; |
|
1578 |
s:= 0; |
|
1579 |
SetLength(GearsNearArray, s); |
|
1580 |
t := GearsList; |
|
10015 | 1581 |
while t <> nil do |
9285 | 1582 |
begin |
12743
f45ffb4cf1e1
Make GearsNear and CheckGearNear check gears across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
12737
diff
changeset
|
1583 |
xc:= (X - t^.X)*(X - t^.X); |
f45ffb4cf1e1
Make GearsNear and CheckGearNear check gears across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
12737
diff
changeset
|
1584 |
xc_left:= ((X - int2hwFloat(RightX-LeftX)) - t^.X)*((X - int2hwFloat(RightX-LeftX)) - t^.X); |
f45ffb4cf1e1
Make GearsNear and CheckGearNear check gears across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
12737
diff
changeset
|
1585 |
xc_right := ((X + int2hwFloat(RightX-LeftX)) - t^.X)*((X + int2hwFloat(RightX-LeftX)) - t^.X); |
f45ffb4cf1e1
Make GearsNear and CheckGearNear check gears across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
12737
diff
changeset
|
1586 |
yc:= (Y - t^.Y)*(Y - t^.Y); |
f45ffb4cf1e1
Make GearsNear and CheckGearNear check gears across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
12737
diff
changeset
|
1587 |
if (t^.Kind = Kind) |
f45ffb4cf1e1
Make GearsNear and CheckGearNear check gears across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
12737
diff
changeset
|
1588 |
and ((xc + yc < int2hwFloat(r)) |
f45ffb4cf1e1
Make GearsNear and CheckGearNear check gears across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
12737
diff
changeset
|
1589 |
or ((WorldEdge = weWrap) and |
f45ffb4cf1e1
Make GearsNear and CheckGearNear check gears across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
12737
diff
changeset
|
1590 |
((xc_left + yc < int2hwFloat(r)) or |
f45ffb4cf1e1
Make GearsNear and CheckGearNear check gears across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
12737
diff
changeset
|
1591 |
(xc_right + yc < int2hwFloat(r))))) then |
f45ffb4cf1e1
Make GearsNear and CheckGearNear check gears across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
12737
diff
changeset
|
1592 |
begin |
f45ffb4cf1e1
Make GearsNear and CheckGearNear check gears across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
12737
diff
changeset
|
1593 |
inc(s); |
f45ffb4cf1e1
Make GearsNear and CheckGearNear check gears across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
12737
diff
changeset
|
1594 |
SetLength(GearsNearArray, s); |
f45ffb4cf1e1
Make GearsNear and CheckGearNear check gears across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
12737
diff
changeset
|
1595 |
GearsNearArray[s - 1] := t; |
f45ffb4cf1e1
Make GearsNear and CheckGearNear check gears across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
12737
diff
changeset
|
1596 |
end; |
f45ffb4cf1e1
Make GearsNear and CheckGearNear check gears across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
12737
diff
changeset
|
1597 |
t := t^.NextGear; |
f45ffb4cf1e1
Make GearsNear and CheckGearNear check gears across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
12737
diff
changeset
|
1598 |
end; |
9285 | 1599 |
|
1600 |
GearsNear.size:= s; |
|
1601 |
GearsNear.ar:= @GearsNearArray |
|
1602 |
end; |
|
1603 |
||
14789
185f07ec4d12
New callback: onCaseDrop (called when engine MIGHT drop a crate)
Wuzzy <Wuzzy2@mail.ru>
parents:
14770
diff
changeset
|
1604 |
function SpawnBoxOfSmth: PGear; |
185f07ec4d12
New callback: onCaseDrop (called when engine MIGHT drop a crate)
Wuzzy <Wuzzy2@mail.ru>
parents:
14770
diff
changeset
|
1605 |
var t, aTot, uTot, a, h: LongInt; |
9285 | 1606 |
i: TAmmoType; |
1607 |
begin |
|
14789
185f07ec4d12
New callback: onCaseDrop (called when engine MIGHT drop a crate)
Wuzzy <Wuzzy2@mail.ru>
parents:
14770
diff
changeset
|
1608 |
SpawnBoxOfSmth:= nil; |
15241
ceb289e8a582
King Mode: Fix king placement phase not working correctly with multiple teams in a clan
Wuzzy <Wuzzy2@mail.ru>
parents:
15216
diff
changeset
|
1609 |
if (PlacingHogs) or (PlacingKings) or |
9285 | 1610 |
(cCaseFactor = 0) |
13627
605767bbd022
Move max. number of crate spawns into variable
Wuzzy <Wuzzy2@mail.ru>
parents:
13617
diff
changeset
|
1611 |
or (CountGears(gtCase) >= cMaxCaseDrops) |
9285 | 1612 |
or (GetRandom(cCaseFactor) <> 0) then |
1613 |
exit; |
|
1614 |
||
1615 |
FollowGear:= nil; |
|
1616 |
aTot:= 0; |
|
1617 |
uTot:= 0; |
|
1618 |
for i:= Low(TAmmoType) to High(TAmmoType) do |
|
1619 |
if (Ammoz[i].Ammo.Propz and ammoprop_Utility) = 0 then |
|
1620 |
inc(aTot, Ammoz[i].Probability) |
|
1621 |
else |
|
1622 |
inc(uTot, Ammoz[i].Probability); |
|
1623 |
||
1624 |
t:=0; |
|
1625 |
a:=aTot; |
|
1626 |
h:= 1; |
|
1627 |
||
1628 |
if (aTot+uTot) <> 0 then |
|
1629 |
if ((GameFlags and gfInvulnerable) = 0) then |
|
1630 |
begin |
|
1631 |
h:= cHealthCaseProb * 100; |
|
1632 |
t:= GetRandom(10000); |
|
1633 |
a:= (10000-h)*aTot div (aTot+uTot) |
|
1634 |
end |
|
1635 |
else |
|
1636 |
begin |
|
1637 |
t:= GetRandom(aTot+uTot); |
|
1638 |
h:= 0 |
|
1639 |
end; |
|
1640 |
||
1641 |
||
1642 |
if t<h then |
|
1643 |
begin |
|
1644 |
FollowGear:= AddGear(0, 0, gtCase, 0, _0, _0, 0); |
|
14770
533ac9774279
Add key to display extra gear info tags
Wuzzy <Wuzzy2@mail.ru>
parents:
14595
diff
changeset
|
1645 |
FollowGear^.RenderHealth:= true; |
9285 | 1646 |
FollowGear^.Health:= cHealthCaseAmount; |
1647 |
FollowGear^.Pos:= posCaseHealth; |
|
10506 | 1648 |
// health crate is smaller than the other crates |
1649 |
FollowGear^.Radius := cCaseHealthRadius; |
|
13642
3d14950641a4
Refactor text color variable names, export 2 color values to Lua
Wuzzy <Wuzzy2@mail.ru>
parents:
13629
diff
changeset
|
1650 |
AddCaption(GetEventString(eidNewHealthPack), capcolDefault, capgrpAmmoInfo); |
9285 | 1651 |
end |
1652 |
else if (t<a+h) then |
|
1653 |
begin |
|
1654 |
t:= aTot; |
|
1655 |
if (t > 0) then |
|
1656 |
begin |
|
1657 |
FollowGear:= AddGear(0, 0, gtCase, 0, _0, _0, 0); |
|
1658 |
t:= GetRandom(t); |
|
1659 |
i:= Low(TAmmoType); |
|
1660 |
FollowGear^.Pos:= posCaseAmmo; |
|
1661 |
FollowGear^.AmmoType:= i; |
|
13642
3d14950641a4
Refactor text color variable names, export 2 color values to Lua
Wuzzy <Wuzzy2@mail.ru>
parents:
13629
diff
changeset
|
1662 |
AddCaption(GetEventString(eidNewAmmoPack), capcolDefault, capgrpAmmoInfo); |
9285 | 1663 |
end |
1664 |
end |
|
1665 |
else |
|
1666 |
begin |
|
1667 |
t:= uTot; |
|
1668 |
if (t > 0) then |
|
1669 |
begin |
|
1670 |
FollowGear:= AddGear(0, 0, gtCase, 0, _0, _0, 0); |
|
1671 |
t:= GetRandom(t); |
|
1672 |
i:= Low(TAmmoType); |
|
1673 |
FollowGear^.Pos:= posCaseUtility; |
|
1674 |
FollowGear^.AmmoType:= i; |
|
13642
3d14950641a4
Refactor text color variable names, export 2 color values to Lua
Wuzzy <Wuzzy2@mail.ru>
parents:
13629
diff
changeset
|
1675 |
AddCaption(GetEventString(eidNewUtilityPack), capcolDefault, capgrpAmmoInfo); |
9285 | 1676 |
end |
1677 |
end; |
|
1678 |
||
1679 |
// handles case of no ammo or utility crates - considered also placing booleans in uAmmos and altering probabilities |
|
1680 |
if (FollowGear <> nil) then |
|
1681 |
begin |
|
1682 |
FindPlace(FollowGear, true, 0, LAND_WIDTH); |
|
14789
185f07ec4d12
New callback: onCaseDrop (called when engine MIGHT drop a crate)
Wuzzy <Wuzzy2@mail.ru>
parents:
14770
diff
changeset
|
1683 |
PlayBoxSpawnTaunt(FollowGear); |
185f07ec4d12
New callback: onCaseDrop (called when engine MIGHT drop a crate)
Wuzzy <Wuzzy2@mail.ru>
parents:
14770
diff
changeset
|
1684 |
SpawnBoxOfSmth:= FollowGear; |
185f07ec4d12
New callback: onCaseDrop (called when engine MIGHT drop a crate)
Wuzzy <Wuzzy2@mail.ru>
parents:
14770
diff
changeset
|
1685 |
end |
185f07ec4d12
New callback: onCaseDrop (called when engine MIGHT drop a crate)
Wuzzy <Wuzzy2@mail.ru>
parents:
14770
diff
changeset
|
1686 |
end; |
9285 | 1687 |
|
14789
185f07ec4d12
New callback: onCaseDrop (called when engine MIGHT drop a crate)
Wuzzy <Wuzzy2@mail.ru>
parents:
14770
diff
changeset
|
1688 |
procedure PlayBoxSpawnTaunt(Gear: PGear); |
185f07ec4d12
New callback: onCaseDrop (called when engine MIGHT drop a crate)
Wuzzy <Wuzzy2@mail.ru>
parents:
14770
diff
changeset
|
1689 |
const |
185f07ec4d12
New callback: onCaseDrop (called when engine MIGHT drop a crate)
Wuzzy <Wuzzy2@mail.ru>
parents:
14770
diff
changeset
|
1690 |
// Max. distance between hog and crate for sndThisOneIsMine taunt |
185f07ec4d12
New callback: onCaseDrop (called when engine MIGHT drop a crate)
Wuzzy <Wuzzy2@mail.ru>
parents:
14770
diff
changeset
|
1691 |
ThisOneIsMineDistance : LongInt = 130; |
185f07ec4d12
New callback: onCaseDrop (called when engine MIGHT drop a crate)
Wuzzy <Wuzzy2@mail.ru>
parents:
14770
diff
changeset
|
1692 |
var d, minD: LongInt; |
185f07ec4d12
New callback: onCaseDrop (called when engine MIGHT drop a crate)
Wuzzy <Wuzzy2@mail.ru>
parents:
14770
diff
changeset
|
1693 |
gi, closestHog: PGear; |
185f07ec4d12
New callback: onCaseDrop (called when engine MIGHT drop a crate)
Wuzzy <Wuzzy2@mail.ru>
parents:
14770
diff
changeset
|
1694 |
begin |
14043
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1695 |
// Taunt |
14789
185f07ec4d12
New callback: onCaseDrop (called when engine MIGHT drop a crate)
Wuzzy <Wuzzy2@mail.ru>
parents:
14770
diff
changeset
|
1696 |
if (Gear <> nil) then |
14043
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1697 |
begin |
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1698 |
// Look for hog closest to the crate (on the X axis) |
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1699 |
gi := GearsList; |
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1700 |
minD := LAND_WIDTH + ThisOneIsMineDistance + 1; |
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1701 |
closestHog:= nil; |
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1702 |
while gi <> nil do |
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1703 |
begin |
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1704 |
if (gi^.Kind = gtHedgehog) then |
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1705 |
begin |
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1706 |
// Y axis is ignored to simplify calculations |
14789
185f07ec4d12
New callback: onCaseDrop (called when engine MIGHT drop a crate)
Wuzzy <Wuzzy2@mail.ru>
parents:
14770
diff
changeset
|
1707 |
d := hwRound(hwAbs(gi^.X - Gear^.X)); |
14043
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1708 |
if d < minD then |
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1709 |
begin |
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1710 |
minD := d; |
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1711 |
closestHog:= gi; |
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1712 |
end; |
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1713 |
end; |
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1714 |
gi := gi^.NextGear; |
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1715 |
end; |
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1716 |
|
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1717 |
// Is closest hog close enough to the crate (on the X axis)? |
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1718 |
if (closestHog <> nil) and (closestHog^.Hedgehog <> nil) and (minD <= ThisOneIsMineDistance) then |
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1719 |
// If so, there's a chance for a special taunt |
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1720 |
if random(3) > 0 then |
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1721 |
AddVoice(sndThisOneIsMine, closestHog^.Hedgehog^.Team^.voicepack) |
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1722 |
else |
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1723 |
AddVoice(sndReinforce, CurrentTeam^.voicepack) |
14035 | 1724 |
else |
14043
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1725 |
// Default crate drop taunt |
14035 | 1726 |
AddVoice(sndReinforce, CurrentTeam^.voicepack); |
14043
e155b300d49f
Only play sndThisOneIsMine if crate drops close to hog
Wuzzy <Wuzzy2@mail.ru>
parents:
14035
diff
changeset
|
1727 |
end; |
9285 | 1728 |
end; |
1729 |
||
1730 |
||
1731 |
function GetAmmo(Hedgehog: PHedgehog): TAmmoType; |
|
1732 |
var t, aTot: LongInt; |
|
1733 |
i: TAmmoType; |
|
1734 |
begin |
|
1735 |
Hedgehog:= Hedgehog; // avoid hint |
|
1736 |
||
1737 |
aTot:= 0; |
|
1738 |
for i:= Low(TAmmoType) to High(TAmmoType) do |
|
1739 |
if (Ammoz[i].Ammo.Propz and ammoprop_Utility) = 0 then |
|
1740 |
inc(aTot, Ammoz[i].Probability); |
|
1741 |
||
1742 |
t:= aTot; |
|
1743 |
i:= Low(TAmmoType); |
|
1744 |
if (t > 0) then |
|
1745 |
begin |
|
1746 |
t:= GetRandom(t); |
|
1747 |
while t >= 0 do |
|
1748 |
begin |
|
1749 |
inc(i); |
|
1750 |
if (Ammoz[i].Ammo.Propz and ammoprop_Utility) = 0 then |
|
1751 |
dec(t, Ammoz[i].Probability) |
|
1752 |
end |
|
1753 |
end; |
|
1754 |
GetAmmo:= i |
|
1755 |
end; |
|
1756 |
||
1757 |
function GetUtility(Hedgehog: PHedgehog): TAmmoType; |
|
1758 |
var t, uTot: LongInt; |
|
1759 |
i: TAmmoType; |
|
1760 |
begin |
|
1761 |
||
1762 |
uTot:= 0; |
|
1763 |
for i:= Low(TAmmoType) to High(TAmmoType) do |
|
1764 |
if ((Ammoz[i].Ammo.Propz and ammoprop_Utility) <> 0) |
|
1765 |
and ((Hedgehog^.Team^.HedgehogsNumber > 1) or (Ammoz[i].Ammo.AmmoType <> amSwitch)) then |
|
1766 |
inc(uTot, Ammoz[i].Probability); |
|
1767 |
||
1768 |
t:= uTot; |
|
1769 |
i:= Low(TAmmoType); |
|
1770 |
if (t > 0) then |
|
1771 |
begin |
|
1772 |
t:= GetRandom(t); |
|
1773 |
while t >= 0 do |
|
1774 |
begin |
|
1775 |
inc(i); |
|
1776 |
if ((Ammoz[i].Ammo.Propz and ammoprop_Utility) <> 0) and ((Hedgehog^.Team^.HedgehogsNumber > 1) |
|
1777 |
or (Ammoz[i].Ammo.AmmoType <> amSwitch)) then |
|
1778 |
dec(t, Ammoz[i].Probability) |
|
1779 |
end |
|
1780 |
end; |
|
1781 |
GetUtility:= i |
|
1782 |
end; |
|
1783 |
||
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1784 |
(* |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1785 |
Intended to check Gear X/Y against the map left/right edges and apply one of the world modes |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1786 |
* Normal - infinite world, do nothing |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1787 |
* Wrap (entering left edge exits at same height on right edge) |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1788 |
* Bounce (striking edge is treated as a 100% elasticity bounce) |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1789 |
* From the depths (same as from sky, but from sea, with submersible flag set) |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1790 |
|
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1791 |
Trying to make the checks a little broader than on first pass to catch things that don't move normally. |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1792 |
*) |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1793 |
function WorldWrap(var Gear: PGear): boolean; |
14584
ca9c632db2cf
Bounce off gears at bouncy world edge only if they move towards it
Wuzzy <Wuzzy2@mail.ru>
parents:
14555
diff
changeset
|
1794 |
var bounced: boolean; |
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1795 |
begin |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1796 |
WorldWrap:= false; |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1797 |
if WorldEdge = weNone then exit(false); |
14303
6015b74eea55
overall, using LongInt for leftX/rightX results in fewer casts, since most comparisons are against ints.
nemo
parents:
14224
diff
changeset
|
1798 |
if (hwRound(Gear^.X) < leftX) or |
6015b74eea55
overall, using LongInt for leftX/rightX results in fewer casts, since most comparisons are against ints.
nemo
parents:
14224
diff
changeset
|
1799 |
(hwRound(Gear^.X) > rightX) then |
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1800 |
begin |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1801 |
if WorldEdge = weWrap then |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1802 |
begin |
14303
6015b74eea55
overall, using LongInt for leftX/rightX results in fewer casts, since most comparisons are against ints.
nemo
parents:
14224
diff
changeset
|
1803 |
if (hwRound(Gear^.X) < leftX) then |
10160 | 1804 |
Gear^.X:= Gear^.X + int2hwfloat(rightX - leftX) |
1805 |
else Gear^.X:= Gear^.X - int2hwfloat(rightX - leftX); |
|
9557 | 1806 |
LeftImpactTimer:= 150; |
14592
1d3dc553829c
Fix WorldWrap returning sometimes true unjustifiably
Wuzzy <Wuzzy2@mail.ru>
parents:
14584
diff
changeset
|
1807 |
RightImpactTimer:= 150; |
1d3dc553829c
Fix WorldWrap returning sometimes true unjustifiably
Wuzzy <Wuzzy2@mail.ru>
parents:
14584
diff
changeset
|
1808 |
WorldWrap:= true; |
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1809 |
end |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1810 |
else if WorldEdge = weBounce then |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1811 |
begin |
14584
ca9c632db2cf
Bounce off gears at bouncy world edge only if they move towards it
Wuzzy <Wuzzy2@mail.ru>
parents:
14555
diff
changeset
|
1812 |
bounced:= false; |
15244
32678e65b25e
Bounce world edge: Fix buggy gear behaviour if gear spawned inside bounce edge area
Wuzzy <Wuzzy2@mail.ru>
parents:
15241
diff
changeset
|
1813 |
// Bounce left |
15199
d3998dcc076f
weBounce: Fix some weird bouncing behaviour
Wuzzy <Wuzzy2@mail.ru>
parents:
15171
diff
changeset
|
1814 |
if (hwRound(Gear^.X) - Gear^.Radius < leftX) and (((hwSign(Gear^.dX) = -1) and (not isZero(Gear^.dX))) or (Gear^.Kind = gtHedgehog)) then |
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1815 |
begin |
9557 | 1816 |
LeftImpactTimer:= 333; |
15244
32678e65b25e
Bounce world edge: Fix buggy gear behaviour if gear spawned inside bounce edge area
Wuzzy <Wuzzy2@mail.ru>
parents:
15241
diff
changeset
|
1817 |
// Set X coordinate to bounce edge, unless the gear spawned inside the bounce edge before |
32678e65b25e
Bounce world edge: Fix buggy gear behaviour if gear spawned inside bounce edge area
Wuzzy <Wuzzy2@mail.ru>
parents:
15241
diff
changeset
|
1818 |
if (Gear^.State and gstInBounceEdge) = 0 then |
32678e65b25e
Bounce world edge: Fix buggy gear behaviour if gear spawned inside bounce edge area
Wuzzy <Wuzzy2@mail.ru>
parents:
15241
diff
changeset
|
1819 |
Gear^.X:= int2hwfloat(leftX + Gear^.Radius); |
32678e65b25e
Bounce world edge: Fix buggy gear behaviour if gear spawned inside bounce edge area
Wuzzy <Wuzzy2@mail.ru>
parents:
15241
diff
changeset
|
1820 |
// Invert horizontal speed |
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1821 |
Gear^.dX.isNegative:= false; |
14584
ca9c632db2cf
Bounce off gears at bouncy world edge only if they move towards it
Wuzzy <Wuzzy2@mail.ru>
parents:
14555
diff
changeset
|
1822 |
bounced:= true; |
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1823 |
end |
15244
32678e65b25e
Bounce world edge: Fix buggy gear behaviour if gear spawned inside bounce edge area
Wuzzy <Wuzzy2@mail.ru>
parents:
15241
diff
changeset
|
1824 |
// Bounce right |
15199
d3998dcc076f
weBounce: Fix some weird bouncing behaviour
Wuzzy <Wuzzy2@mail.ru>
parents:
15171
diff
changeset
|
1825 |
else if (hwRound(Gear^.X) + Gear^.Radius > rightX) and (((hwSign(Gear^.dX) = 1) and (not isZero(Gear^.dX))) or (Gear^.Kind = gtHedgehog)) then |
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1826 |
begin |
9557 | 1827 |
RightImpactTimer:= 333; |
15244
32678e65b25e
Bounce world edge: Fix buggy gear behaviour if gear spawned inside bounce edge area
Wuzzy <Wuzzy2@mail.ru>
parents:
15241
diff
changeset
|
1828 |
// Set X coordinate to bounce edge, unless the gear spawned inside the bounce edge before |
32678e65b25e
Bounce world edge: Fix buggy gear behaviour if gear spawned inside bounce edge area
Wuzzy <Wuzzy2@mail.ru>
parents:
15241
diff
changeset
|
1829 |
if (Gear^.State and gstInBounceEdge) = 0 then |
32678e65b25e
Bounce world edge: Fix buggy gear behaviour if gear spawned inside bounce edge area
Wuzzy <Wuzzy2@mail.ru>
parents:
15241
diff
changeset
|
1830 |
Gear^.X:= int2hwfloat(rightX - Gear^.Radius); |
32678e65b25e
Bounce world edge: Fix buggy gear behaviour if gear spawned inside bounce edge area
Wuzzy <Wuzzy2@mail.ru>
parents:
15241
diff
changeset
|
1831 |
// Invert horizontal speed |
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1832 |
Gear^.dX.isNegative:= true; |
14584
ca9c632db2cf
Bounce off gears at bouncy world edge only if they move towards it
Wuzzy <Wuzzy2@mail.ru>
parents:
14555
diff
changeset
|
1833 |
bounced:= true; |
9557 | 1834 |
end; |
15244
32678e65b25e
Bounce world edge: Fix buggy gear behaviour if gear spawned inside bounce edge area
Wuzzy <Wuzzy2@mail.ru>
parents:
15241
diff
changeset
|
1835 |
// Clear gstInBounceEdge when gear is no longer inside a bounce edge area |
32678e65b25e
Bounce world edge: Fix buggy gear behaviour if gear spawned inside bounce edge area
Wuzzy <Wuzzy2@mail.ru>
parents:
15241
diff
changeset
|
1836 |
if ((Gear^.State and gstInBounceEdge) <> 0) and (hwRound(Gear^.X) - Gear^.Radius >= leftX) and (hwRound(Gear^.X) + Gear^.Radius <= rightX) then |
32678e65b25e
Bounce world edge: Fix buggy gear behaviour if gear spawned inside bounce edge area
Wuzzy <Wuzzy2@mail.ru>
parents:
15241
diff
changeset
|
1837 |
Gear^.State:= Gear^.State and (not gstInBounceEdge); |
14592
1d3dc553829c
Fix WorldWrap returning sometimes true unjustifiably
Wuzzy <Wuzzy2@mail.ru>
parents:
14584
diff
changeset
|
1838 |
if (bounced) then |
1d3dc553829c
Fix WorldWrap returning sometimes true unjustifiably
Wuzzy <Wuzzy2@mail.ru>
parents:
14584
diff
changeset
|
1839 |
begin |
1d3dc553829c
Fix WorldWrap returning sometimes true unjustifiably
Wuzzy <Wuzzy2@mail.ru>
parents:
14584
diff
changeset
|
1840 |
WorldWrap:= true; |
14595
6e5cda26f676
Tweak bounce effects of some gears
Wuzzy <Wuzzy2@mail.ru>
parents:
14593
diff
changeset
|
1841 |
if (Gear^.dX.QWordValue > _0_001.QWordValue) then |
14592
1d3dc553829c
Fix WorldWrap returning sometimes true unjustifiably
Wuzzy <Wuzzy2@mail.ru>
parents:
14584
diff
changeset
|
1842 |
AddBounceEffectForGear(Gear); |
1d3dc553829c
Fix WorldWrap returning sometimes true unjustifiably
Wuzzy <Wuzzy2@mail.ru>
parents:
14584
diff
changeset
|
1843 |
end; |
1d3dc553829c
Fix WorldWrap returning sometimes true unjustifiably
Wuzzy <Wuzzy2@mail.ru>
parents:
14584
diff
changeset
|
1844 |
end |
1d3dc553829c
Fix WorldWrap returning sometimes true unjustifiably
Wuzzy <Wuzzy2@mail.ru>
parents:
14584
diff
changeset
|
1845 |
else |
1d3dc553829c
Fix WorldWrap returning sometimes true unjustifiably
Wuzzy <Wuzzy2@mail.ru>
parents:
14584
diff
changeset
|
1846 |
WorldWrap:= true; |
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1847 |
end; |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1848 |
end; |
9285 | 1849 |
|
14535
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1850 |
(* |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1851 |
Applies wrap-around logic for the target of homing gears. |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1852 |
|
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1853 |
In wrap-around world edge, the shortest way may to the target might |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1854 |
be across the border, so the X value of the target would lead the |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1855 |
gear to the wrong direction across the whole map. This procedure |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1856 |
changes the target X in this case. |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1857 |
This function must be called after the gear passed through |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1858 |
the wrap-around world edge (WorldWrap returned true). |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1859 |
|
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1860 |
No-op for other world edges. |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1861 |
|
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1862 |
Returns true if target has been changed. |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1863 |
*) |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1864 |
function HomingWrap(var Gear: PGear): boolean; |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1865 |
var dist_center, dist_right, dist_left: hwFloat; |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1866 |
begin |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1867 |
if WorldEdge = weWrap then |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1868 |
begin |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1869 |
HomingWrap:= false; |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1870 |
// We just check the same target 3 times: |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1871 |
// 1) in current section (no change) |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1872 |
// 2) clone in the right section |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1873 |
// 3) clone in the left section |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1874 |
// The gear will go for the target with the shortest distance to the gear. |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1875 |
// For simplicity, we only check distance on the X axis. |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1876 |
dist_center:= hwAbs(Gear^.X - int2hwFloat(Gear^.Target.X)); |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1877 |
dist_right:= hwAbs(Gear^.X - int2hwFloat(Gear^.Target.X + (RightX-LeftX))); |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1878 |
dist_left:= hwAbs(Gear^.X - int2hwFloat(Gear^.Target.X - (RightX-LeftX))); |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1879 |
if (dist_left < dist_right) and (dist_left < dist_center) then |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1880 |
begin |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1881 |
dec(Gear^.Target.X, RightX-LeftX); |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1882 |
HomingWrap:= true; |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1883 |
end |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1884 |
else if (dist_right < dist_left) and (dist_right < dist_center) then |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1885 |
begin |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1886 |
inc(Gear^.Target.X, RightX-LeftX); |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1887 |
HomingWrap:= true; |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1888 |
end; |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1889 |
end; |
5ac181cb2396
Fix bee targeting fail across wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
14358
diff
changeset
|
1890 |
end; |
13609
13f68f3e7153
Add bounce effect to cake when it touches bounce edge
Wuzzy <Wuzzy2@mail.ru>
parents:
13604
diff
changeset
|
1891 |
|
13f68f3e7153
Add bounce effect to cake when it touches bounce edge
Wuzzy <Wuzzy2@mail.ru>
parents:
13604
diff
changeset
|
1892 |
// Add an audiovisual bounce effect for gear after it bounced from bouncy material. |
13f68f3e7153
Add bounce effect to cake when it touches bounce edge
Wuzzy <Wuzzy2@mail.ru>
parents:
13604
diff
changeset
|
1893 |
// Graphical effect is based on speed. |
10508 | 1894 |
procedure AddBounceEffectForGear(Gear: PGear); |
13609
13f68f3e7153
Add bounce effect to cake when it touches bounce edge
Wuzzy <Wuzzy2@mail.ru>
parents:
13604
diff
changeset
|
1895 |
begin |
13f68f3e7153
Add bounce effect to cake when it touches bounce edge
Wuzzy <Wuzzy2@mail.ru>
parents:
13604
diff
changeset
|
1896 |
AddBounceEffectForGear(Gear, hwFloat2Float(Gear^.Density * hwAbs(Gear^.dY) + hwAbs(Gear^.dX)) / 1.5); |
13f68f3e7153
Add bounce effect to cake when it touches bounce edge
Wuzzy <Wuzzy2@mail.ru>
parents:
13604
diff
changeset
|
1897 |
end; |
13f68f3e7153
Add bounce effect to cake when it touches bounce edge
Wuzzy <Wuzzy2@mail.ru>
parents:
13604
diff
changeset
|
1898 |
|
13f68f3e7153
Add bounce effect to cake when it touches bounce edge
Wuzzy <Wuzzy2@mail.ru>
parents:
13604
diff
changeset
|
1899 |
// Same as above, but can specify the size of bounce image with imageScale manually. |
13f68f3e7153
Add bounce effect to cake when it touches bounce edge
Wuzzy <Wuzzy2@mail.ru>
parents:
13604
diff
changeset
|
1900 |
procedure AddBounceEffectForGear(Gear: PGear; imageScale: Single); |
10508 | 1901 |
var boing: PVisualGear; |
1902 |
begin |
|
14595
6e5cda26f676
Tweak bounce effects of some gears
Wuzzy <Wuzzy2@mail.ru>
parents:
14593
diff
changeset
|
1903 |
if (Gear^.Density < _0_01) or (Gear^.Radius < 2) then |
13572
a71e6856ffab
Fix freeze ray not working through wrap world edge; add DrawLineWrapped
Wuzzy <Wuzzy2@mail.ru>
parents:
13568
diff
changeset
|
1904 |
exit; |
10508 | 1905 |
boing:= AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtStraightShot, 0, false, 1); |
1906 |
if boing <> nil then |
|
1907 |
with boing^ do |
|
1908 |
begin |
|
1909 |
Angle:= random(360); |
|
1910 |
dx:= 0; |
|
1911 |
dy:= 0; |
|
1912 |
FrameTicks:= 200; |
|
13609
13f68f3e7153
Add bounce effect to cake when it touches bounce edge
Wuzzy <Wuzzy2@mail.ru>
parents:
13604
diff
changeset
|
1913 |
Scale:= imageScale; |
10508 | 1914 |
State:= ord(sprBoing) |
1915 |
end; |
|
13872
f01798038c2e
Rename amDuck and related symbols to amCreeper, gtCreeper, etc.
Wuzzy <Wuzzy2@mail.ru>
parents:
13807
diff
changeset
|
1916 |
PlaySound(sndMelonImpact, true) |
10508 | 1917 |
end; |
1918 |
||
15015
d9de740e194c
Add utility function to get hog left/right looking dir
Wuzzy <Wuzzy2@mail.ru>
parents:
14947
diff
changeset
|
1919 |
function IsHogFacingLeft(Gear: PGear): boolean; |
d9de740e194c
Add utility function to get hog left/right looking dir
Wuzzy <Wuzzy2@mail.ru>
parents:
14947
diff
changeset
|
1920 |
var sign: LongInt; |
d9de740e194c
Add utility function to get hog left/right looking dir
Wuzzy <Wuzzy2@mail.ru>
parents:
14947
diff
changeset
|
1921 |
begin |
d9de740e194c
Add utility function to get hog left/right looking dir
Wuzzy <Wuzzy2@mail.ru>
parents:
14947
diff
changeset
|
1922 |
sign:= hwSign(Gear^.dX); |
15167
6b7d92fa4912
Keep hog facing direction while on parachute
Wuzzy <Wuzzy2@mail.ru>
parents:
15073
diff
changeset
|
1923 |
if (CurAmmoGear <> nil) and (CurAmmoGear^.Kind = gtParachute) then |
6b7d92fa4912
Keep hog facing direction while on parachute
Wuzzy <Wuzzy2@mail.ru>
parents:
15073
diff
changeset
|
1924 |
IsHogFacingLeft:= CurAmmoGear^.Tag = -1 |
6b7d92fa4912
Keep hog facing direction while on parachute
Wuzzy <Wuzzy2@mail.ru>
parents:
15073
diff
changeset
|
1925 |
else if ((Gear^.State and gstHHHJump) <> 0) and (Gear^.Hedgehog^.Effects[heArtillery] = 0) then |
15015
d9de740e194c
Add utility function to get hog left/right looking dir
Wuzzy <Wuzzy2@mail.ru>
parents:
14947
diff
changeset
|
1926 |
IsHogFacingLeft:= sign > 0 |
d9de740e194c
Add utility function to get hog left/right looking dir
Wuzzy <Wuzzy2@mail.ru>
parents:
14947
diff
changeset
|
1927 |
else |
d9de740e194c
Add utility function to get hog left/right looking dir
Wuzzy <Wuzzy2@mail.ru>
parents:
14947
diff
changeset
|
1928 |
IsHogFacingLeft:= sign < 0; |
d9de740e194c
Add utility function to get hog left/right looking dir
Wuzzy <Wuzzy2@mail.ru>
parents:
14947
diff
changeset
|
1929 |
end; |
d9de740e194c
Add utility function to get hog left/right looking dir
Wuzzy <Wuzzy2@mail.ru>
parents:
14947
diff
changeset
|
1930 |
|
11847 | 1931 |
function IsHogLocal(HH: PHedgehog): boolean; |
1932 |
begin |
|
15073
1a754860b0e5
Refactor definition of "local" clans
Wuzzy <Wuzzy2@mail.ru>
parents:
15015
diff
changeset
|
1933 |
IsHogLocal:= (not (HH^.Team^.ExtDriven or (HH^.BotLevel > 0))) or (HH^.Team^.Clan^.LocalOrAlly) or (GameType = gmtDemo); |
11847 | 1934 |
end; |
1935 |
||
6581 | 1936 |
end. |