author | wuzzy |
Sun, 21 Dec 2014 09:27:57 +0100 | |
changeset 10698 | aa3dfb4df603 |
parent 10668 | a15d57d941a1 |
child 10789 | acbf69e2e5cf |
permissions | -rw-r--r-- |
6581 | 1 |
(* |
2 |
* Hedgewars, a free turn based strategy game |
|
9998 | 3 |
* Copyright (c) 2004-2014 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); |
10508 | 28 |
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
|
29 |
|
6581 | 30 |
function ModifyDamage(dmg: Longword; Gear: PGear): Longword; |
31 |
procedure ApplyDamage(Gear: PGear; AttackerHog: PHedgehog; Damage: Longword; Source: TDamageSource); |
|
32 |
procedure spawnHealthTagForHH(HHGear: PGear; dmg: Longword); |
|
33 |
procedure HHHurt(Hedgehog: PHedgehog; Source: TDamageSource); |
|
34 |
procedure CheckHHDamage(Gear: PGear); |
|
35 |
procedure CalcRotationDirAngle(Gear: PGear); |
|
8947
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8763
diff
changeset
|
36 |
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
|
37 |
|
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6888
diff
changeset
|
38 |
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
|
39 |
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
|
40 |
|
6581 | 41 |
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
|
42 |
function CheckGearDrowning(var Gear: PGear): boolean; |
7592 | 43 |
procedure CheckCollision(Gear: PGear); inline; |
44 |
procedure CheckCollisionWithLand(Gear: PGear); inline; |
|
6581 | 45 |
|
9285 | 46 |
procedure AmmoShove(Ammo: PGear; Damage, Power: LongInt); |
47 |
function GearsNear(X, Y: hwFloat; Kind: TGearType; r: LongInt): PGearArrayS; |
|
48 |
procedure SpawnBoxOfSmth; |
|
49 |
procedure ShotgunShot(Gear: PGear); |
|
50 |
||
51 |
procedure SetAllToActive; |
|
52 |
procedure SetAllHHToActive(Ice: boolean); |
|
9954 | 53 |
procedure SetAllHHToActive(); inline; |
9285 | 54 |
|
55 |
function GetAmmo(Hedgehog: PHedgehog): TAmmoType; |
|
56 |
function GetUtility(Hedgehog: PHedgehog): TAmmoType; |
|
57 |
||
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
58 |
function WorldWrap(var Gear: PGear): boolean; |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
59 |
|
9285 | 60 |
|
61 |
||
7719
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
62 |
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
|
63 |
|
6581 | 64 |
var doStepHandlers: array[TGearType] of TGearStepProcedure; |
65 |
||
66 |
implementation |
|
9285 | 67 |
uses uSound, uCollisions, uUtils, uConsts, uVisualGears, uAIMisc, |
6581 | 68 |
uVariables, uLandGraphics, uScript, uStats, uCaptions, uTeams, uStore, |
10015 | 69 |
uLocale, uTextures, uRenderUtils, uRandom, SDLh, uDebug, |
9285 | 70 |
uGearsList, Math, uVisualGearsList, uGearsHandlersMess, |
71 |
uGearsHedgehog; |
|
6581 | 72 |
|
6986
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6888
diff
changeset
|
73 |
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
|
74 |
begin |
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6888
diff
changeset
|
75 |
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
|
76 |
end; |
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6888
diff
changeset
|
77 |
|
6581 | 78 |
procedure doMakeExplosion(X, Y, Radius: LongInt; AttackingHog: PHedgehog; Mask: Longword; const Tint: LongWord); |
79 |
var Gear: PGear; |
|
6769
44ad49a3a126
Add drowning to grenade too, try some little optimisations
nemo
parents:
6765
diff
changeset
|
80 |
dmg, dmgBase: LongInt; |
6765 | 81 |
fX, fY, tdX, tdY: hwFloat; |
6581 | 82 |
vg: PVisualGear; |
83 |
i, cnt: LongInt; |
|
10653 | 84 |
wrap: boolean; |
6581 | 85 |
begin |
86 |
if Radius > 4 then AddFileLog('Explosion: at (' + inttostr(x) + ',' + inttostr(y) + ')'); |
|
87 |
if Radius > 25 then KickFlakes(Radius, X, Y); |
|
88 |
||
89 |
if ((Mask and EXPLNoGfx) = 0) then |
|
90 |
begin |
|
91 |
vg:= nil; |
|
92 |
if Radius > 50 then vg:= AddVisualGear(X, Y, vgtBigExplosion) |
|
93 |
else if Radius > 10 then vg:= AddVisualGear(X, Y, vgtExplosion); |
|
94 |
if vg <> nil then |
|
95 |
vg^.Tint:= Tint; |
|
96 |
end; |
|
97 |
if (Mask and EXPLAutoSound) <> 0 then PlaySound(sndExplosion); |
|
98 |
||
6765 | 99 |
(*if (Mask and EXPLAllDamageInRadius) = 0 then |
6581 | 100 |
dmgRadius:= Radius shl 1 |
101 |
else |
|
102 |
dmgRadius:= Radius; |
|
6765 | 103 |
dmgBase:= dmgRadius + cHHRadius div 2;*) |
104 |
dmgBase:= Radius shl 1 + cHHRadius div 2; |
|
10653 | 105 |
|
106 |
// we might have to run twice if weWrap is enabled |
|
107 |
wrap:= false; |
|
10659 | 108 |
repeat |
10653 | 109 |
|
10654 | 110 |
fX:= int2hwFloat(X); |
111 |
fY:= int2hwFloat(Y); |
|
112 |
Gear:= GearsList; |
|
113 |
||
6581 | 114 |
while Gear <> nil do |
115 |
begin |
|
116 |
dmg:= 0; |
|
117 |
//dmg:= dmgRadius + cHHRadius div 2 - hwRound(Distance(Gear^.X - int2hwFloat(X), Gear^.Y - int2hwFloat(Y))); |
|
118 |
//if (dmg > 1) and |
|
119 |
if (Gear^.State and gstNoDamage) = 0 then |
|
120 |
begin |
|
121 |
case Gear^.Kind of |
|
122 |
gtHedgehog, |
|
123 |
gtMine, |
|
124 |
gtBall, |
|
125 |
gtMelonPiece, |
|
126 |
gtGrenade, |
|
127 |
gtClusterBomb, |
|
128 |
// gtCluster, too game breaking I think |
|
129 |
gtSMine, |
|
130 |
gtCase, |
|
131 |
gtTarget, |
|
132 |
gtFlame, |
|
7754 | 133 |
gtKnife, |
8161 | 134 |
gtExplosives: begin //, |
135 |
//gtStructure: begin |
|
6581 | 136 |
// Run the calcs only once we know we have a type that will need damage |
6765 | 137 |
tdX:= Gear^.X-fX; |
138 |
tdY:= Gear^.Y-fY; |
|
7721 | 139 |
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
|
140 |
dmg:= dmgBase - hwRound(Distance(tdX, tdY)); |
6581 | 141 |
if dmg > 1 then |
142 |
begin |
|
143 |
dmg:= ModifyDamage(min(dmg div 2, Radius), Gear); |
|
144 |
//AddFileLog('Damage: ' + inttostr(dmg)); |
|
145 |
if (Mask and EXPLNoDamage) = 0 then |
|
146 |
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
|
147 |
if (Gear^.Kind <> gtHedgehog) or (Gear^.Hedgehog^.Effects[heInvulnerable] = 0) then |
6581 | 148 |
ApplyDamage(Gear, AttackingHog, dmg, dsExplosion) |
149 |
else |
|
150 |
Gear^.State:= Gear^.State or gstWinner; |
|
151 |
end; |
|
152 |
if ((Mask and EXPLDoNotTouchAny) = 0) and (((Mask and EXPLDoNotTouchHH) = 0) or (Gear^.Kind <> gtHedgehog)) then |
|
153 |
begin |
|
154 |
DeleteCI(Gear); |
|
6765 | 155 |
Gear^.dX:= Gear^.dX + SignAs(_0_005 * dmg + cHHKick, tdX)/(Gear^.Density/_3); |
156 |
Gear^.dY:= Gear^.dY + SignAs(_0_005 * dmg + cHHKick, tdY)/(Gear^.Density/_3); |
|
6581 | 157 |
|
158 |
Gear^.State:= (Gear^.State or gstMoving) and (not gstLoser); |
|
7767 | 159 |
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
|
160 |
if (Gear^.Kind = gtHedgehog) and (Gear^.Hedgehog^.Effects[heInvulnerable] = 0) then |
6581 | 161 |
Gear^.State:= (Gear^.State or gstMoving) and (not gstWinner); |
162 |
Gear^.Active:= true; |
|
163 |
if Gear^.Kind <> gtFlame then FollowGear:= Gear |
|
164 |
end; |
|
9685
7d925e82e572
Tweak trophyrace to work better w/ skip (probably, needs testing), drop Invulnerable in favour of effects - heInvulnerable is already in effects,
nemo
parents:
9561
diff
changeset
|
165 |
if ((Mask and EXPLPoisoned) <> 0) and (Gear^.Kind = gtHedgehog) and (Gear^.Hedgehog^.Effects[heInvulnerable] = 0) and (Gear^.State and gstHHDeath = 0) then |
10012
82dd9f0c88f7
Make poison damage possibly variable (might as well since effects is a count). Scripts might find it handy.
nemo
parents:
10011
diff
changeset
|
166 |
Gear^.Hedgehog^.Effects[hePoisoned] := 5; |
6581 | 167 |
end; |
168 |
||
169 |
end; |
|
9814 | 170 |
gtGrave: if Mask and EXPLDoNotTouchAny = 0 then |
6581 | 171 |
// Run the calcs only once we know we have a type that will need damage |
172 |
begin |
|
9814 | 173 |
tdX:= Gear^.X-fX; |
174 |
tdY:= Gear^.Y-fY; |
|
175 |
if LongInt(tdX.Round + tdY.Round + 2) < dmgBase then |
|
176 |
dmg:= dmgBase - hwRound(Distance(tdX, tdY)); |
|
177 |
if dmg > 1 then |
|
178 |
begin |
|
179 |
dmg:= ModifyDamage(min(dmg div 2, Radius), Gear); |
|
180 |
Gear^.dY:= - _0_004 * dmg; |
|
181 |
Gear^.Active:= true |
|
182 |
end |
|
183 |
end; |
|
6581 | 184 |
end; |
185 |
end; |
|
186 |
Gear:= Gear^.NextGear |
|
187 |
end; |
|
188 |
||
189 |
if (Mask and EXPLDontDraw) = 0 then |
|
190 |
if (GameFlags and gfSolidLand) = 0 then |
|
191 |
begin |
|
192 |
cnt:= DrawExplosion(X, Y, Radius) div 1608; // approx 2 16x16 circles to erase per chunk |
|
193 |
if (cnt > 0) and (SpritesData[sprChunk].Texture <> nil) then |
|
194 |
for i:= 0 to cnt do |
|
195 |
AddVisualGear(X, Y, vgtChunk) |
|
196 |
end; |
|
197 |
||
10653 | 198 |
if (WorldEdge = weWrap) then |
199 |
begin |
|
200 |
// already wrapped? let's not wrap again! |
|
201 |
if wrap then |
|
202 |
break; |
|
203 |
||
204 |
// Radius + 5 because that's the actual radius the explosion changes graphically |
|
205 |
if X + (Radius + 5) > LongInt(rightX) then |
|
206 |
begin |
|
207 |
dec(X, playWidth); |
|
208 |
wrap:= true; |
|
209 |
end |
|
210 |
else if X - (Radius + 5) < LongInt(leftX) then |
|
211 |
begin |
|
212 |
inc(X, playWidth); |
|
213 |
wrap:= true; |
|
214 |
end; |
|
215 |
end; |
|
216 |
||
217 |
until (not wrap); |
|
218 |
||
6581 | 219 |
uAIMisc.AwareOfExplosion(0, 0, 0) |
220 |
end; |
|
221 |
||
222 |
function ModifyDamage(dmg: Longword; Gear: PGear): Longword; |
|
223 |
var i: hwFloat; |
|
224 |
begin |
|
225 |
(* Invulnerability cannot be placed in here due to still needing kicks |
|
226 |
Not without a new damage machine. |
|
227 |
King check should be in here instead of ApplyDamage since Tiy wants them kicked less |
|
228 |
*) |
|
229 |
i:= _1; |
|
230 |
if (CurrentHedgehog <> nil) and CurrentHedgehog^.King then |
|
231 |
i:= _1_5; |
|
10015 | 232 |
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
|
233 |
(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
|
234 |
ModifyDamage:= hwRound(cDamageModifier * dmg * i * cDamagePercent * _0_5 * _0_01) |
9149 | 235 |
else |
10526
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10512
diff
changeset
|
236 |
ModifyDamage:= hwRound(cDamageModifier * dmg * i * cDamagePercent * _0_01); |
6581 | 237 |
end; |
238 |
||
239 |
procedure ApplyDamage(Gear: PGear; AttackerHog: PHedgehog; Damage: Longword; Source: TDamageSource); |
|
240 |
var s: shortstring; |
|
241 |
vampDmg, tmpDmg, i: Longword; |
|
242 |
vg: PVisualGear; |
|
243 |
begin |
|
244 |
if Damage = 0 then |
|
245 |
exit; // nothing to apply |
|
246 |
||
247 |
if (Gear^.Kind = gtHedgehog) then |
|
248 |
begin |
|
249 |
Gear^.LastDamage := AttackerHog; |
|
250 |
||
251 |
Gear^.Hedgehog^.Team^.Clan^.Flawless:= false; |
|
252 |
HHHurt(Gear^.Hedgehog, Source); |
|
253 |
AddDamageTag(hwRound(Gear^.X), hwRound(Gear^.Y), Damage, Gear^.Hedgehog^.Team^.Clan^.Color); |
|
254 |
tmpDmg:= min(Damage, max(0,Gear^.Health-Gear^.Damage)); |
|
255 |
if (Gear <> CurrentHedgehog^.Gear) and (CurrentHedgehog^.Gear <> nil) and (tmpDmg >= 1) then |
|
256 |
begin |
|
257 |
if cVampiric then |
|
258 |
begin |
|
259 |
vampDmg:= hwRound(int2hwFloat(tmpDmg)*_0_8); |
|
260 |
if vampDmg >= 1 then |
|
261 |
begin |
|
262 |
// was considering pulsing on attack, Tiy thinks it should be permanent while in play |
|
263 |
//CurrentHedgehog^.Gear^.State:= CurrentHedgehog^.Gear^.State or gstVampiric; |
|
264 |
inc(CurrentHedgehog^.Gear^.Health,vampDmg); |
|
265 |
str(vampDmg, s); |
|
266 |
s:= '+' + s; |
|
10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10116
diff
changeset
|
267 |
AddCaption(ansistring(s), CurrentHedgehog^.Team^.Clan^.Color, capgrpAmmoinfo); |
6581 | 268 |
RenderHealth(CurrentHedgehog^); |
269 |
RecountTeamHealth(CurrentHedgehog^.Team); |
|
270 |
i:= 0; |
|
271 |
while i < vampDmg do |
|
272 |
begin |
|
273 |
vg:= AddVisualGear(hwRound(CurrentHedgehog^.Gear^.X), hwRound(CurrentHedgehog^.Gear^.Y), vgtStraightShot); |
|
274 |
if vg <> nil then |
|
275 |
with vg^ do |
|
276 |
begin |
|
277 |
Tint:= $FF0000FF; |
|
278 |
State:= ord(sprHealth) |
|
279 |
end; |
|
280 |
inc(i, 5); |
|
281 |
end; |
|
282 |
end |
|
283 |
end; |
|
10015 | 284 |
if (GameFlags and gfKarma <> 0) and (GameFlags and gfInvulnerable = 0) and |
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
|
285 |
(CurrentHedgehog^.Effects[heInvulnerable] = 0) then |
6581 | 286 |
begin // this cannot just use Damage or it interrupts shotgun and gets you called stupid |
287 |
inc(CurrentHedgehog^.Gear^.Karma, tmpDmg); |
|
288 |
CurrentHedgehog^.Gear^.LastDamage := CurrentHedgehog; |
|
289 |
spawnHealthTagForHH(CurrentHedgehog^.Gear, tmpDmg); |
|
290 |
end; |
|
8330 | 291 |
uStats.HedgehogDamaged(Gear, AttackerHog, Damage, false); |
6581 | 292 |
end; |
10526
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10512
diff
changeset
|
293 |
|
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10512
diff
changeset
|
294 |
if AprilOne and (Gear^.Hedgehog^.Hat = 'fr_tomato') and (Damage > 2) then |
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10512
diff
changeset
|
295 |
for i := 0 to random(min(Damage,20))+5 do |
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10512
diff
changeset
|
296 |
begin |
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10512
diff
changeset
|
297 |
vg:= AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtStraightShot); |
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10512
diff
changeset
|
298 |
if vg <> nil then |
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10512
diff
changeset
|
299 |
with vg^ do |
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10512
diff
changeset
|
300 |
begin |
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10512
diff
changeset
|
301 |
dx:= 0.001 * (random(100)+10); |
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10512
diff
changeset
|
302 |
dy:= 0.001 * (random(100)+10); |
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10512
diff
changeset
|
303 |
tdy:= -cGravityf; |
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10512
diff
changeset
|
304 |
if random(2) = 0 then |
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10512
diff
changeset
|
305 |
dx := -dx; |
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10512
diff
changeset
|
306 |
//if random(2) = 0 then |
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10512
diff
changeset
|
307 |
// dy := -dy; |
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10512
diff
changeset
|
308 |
FrameTicks:= random(500) + 1000; |
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10512
diff
changeset
|
309 |
State:= ord(sprBubbles); |
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10512
diff
changeset
|
310 |
//Tint:= $bd2f03ff |
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10512
diff
changeset
|
311 |
Tint:= $ff0000ff |
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10512
diff
changeset
|
312 |
end |
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10512
diff
changeset
|
313 |
end |
8199
886ed135665b
Fix crashes and wtf behaviour introduced in r0b8beacff8a5
unc0rr
parents:
8161
diff
changeset
|
314 |
end else |
8161 | 315 |
//else if Gear^.Kind <> gtStructure then // not gtHedgehog nor gtStructure |
6581 | 316 |
Gear^.Hedgehog:= AttackerHog; |
317 |
inc(Gear^.Damage, Damage); |
|
8330 | 318 |
|
6581 | 319 |
ScriptCall('onGearDamage', Gear^.UID, Damage); |
320 |
end; |
|
321 |
||
322 |
procedure spawnHealthTagForHH(HHGear: PGear; dmg: Longword); |
|
323 |
var tag: PVisualGear; |
|
324 |
begin |
|
325 |
tag:= AddVisualGear(hwRound(HHGear^.X), hwRound(HHGear^.Y), vgtHealthTag, dmg); |
|
326 |
if (tag <> nil) then |
|
327 |
tag^.Hedgehog:= HHGear^.Hedgehog; // the tag needs the tag to determine the text color |
|
328 |
AllInactive:= false; |
|
329 |
HHGear^.Active:= true; |
|
330 |
end; |
|
8330 | 331 |
|
6581 | 332 |
procedure HHHurt(Hedgehog: PHedgehog; Source: TDamageSource); |
333 |
begin |
|
9071 | 334 |
if Hedgehog^.Effects[heFrozen] <> 0 then exit; |
10526
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10512
diff
changeset
|
335 |
|
6581 | 336 |
if (Source = dsFall) or (Source = dsExplosion) then |
337 |
case random(3) of |
|
7053 | 338 |
0: PlaySoundV(sndOoff1, Hedgehog^.Team^.voicepack); |
339 |
1: PlaySoundV(sndOoff2, Hedgehog^.Team^.voicepack); |
|
340 |
2: PlaySoundV(sndOoff3, Hedgehog^.Team^.voicepack); |
|
6581 | 341 |
end |
342 |
else if (Source = dsPoison) then |
|
343 |
case random(2) of |
|
7053 | 344 |
0: PlaySoundV(sndPoisonCough, Hedgehog^.Team^.voicepack); |
345 |
1: PlaySoundV(sndPoisonMoan, Hedgehog^.Team^.voicepack); |
|
6581 | 346 |
end |
347 |
else |
|
348 |
case random(4) of |
|
7053 | 349 |
0: PlaySoundV(sndOw1, Hedgehog^.Team^.voicepack); |
350 |
1: PlaySoundV(sndOw2, Hedgehog^.Team^.voicepack); |
|
351 |
2: PlaySoundV(sndOw3, Hedgehog^.Team^.voicepack); |
|
352 |
3: PlaySoundV(sndOw4, Hedgehog^.Team^.voicepack); |
|
6581 | 353 |
end |
354 |
end; |
|
355 |
||
356 |
procedure CheckHHDamage(Gear: PGear); |
|
10015 | 357 |
var |
9809 | 358 |
dmg: LongInt; |
8003 | 359 |
i: LongWord; |
6581 | 360 |
particle: PVisualGear; |
361 |
begin |
|
9071 | 362 |
if _0_4 < Gear^.dY then |
363 |
begin |
|
364 |
dmg := ModifyDamage(1 + hwRound((Gear^.dY - _0_4) * 70), Gear); |
|
365 |
if Gear^.Hedgehog^.Effects[heFrozen] = 0 then |
|
366 |
PlaySound(sndBump) |
|
367 |
else PlaySound(sndFrozenHogImpact); |
|
368 |
if dmg < 1 then |
|
369 |
exit; |
|
6581 | 370 |
|
9809 | 371 |
for i:= min(12, 3 + dmg div 10) downto 0 do |
9071 | 372 |
begin |
373 |
particle := AddVisualGear(hwRound(Gear^.X) - 5 + Random(10), hwRound(Gear^.Y) + 12, vgtDust); |
|
374 |
if particle <> nil then |
|
375 |
particle^.dX := particle^.dX + (Gear^.dX.QWordValue / 21474836480); |
|
376 |
end; |
|
6581 | 377 |
|
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
|
378 |
if ((Gear^.Hedgehog^.Effects[heInvulnerable] <> 0)) then |
9071 | 379 |
exit; |
6581 | 380 |
|
9071 | 381 |
//if _0_6 < Gear^.dY then |
382 |
// PlaySound(sndOw4, Gear^.Hedgehog^.Team^.voicepack) |
|
383 |
//else |
|
384 |
// PlaySound(sndOw1, Gear^.Hedgehog^.Team^.voicepack); |
|
6581 | 385 |
|
9071 | 386 |
if Gear^.LastDamage <> nil then |
387 |
ApplyDamage(Gear, Gear^.LastDamage, dmg, dsFall) |
|
388 |
else |
|
389 |
ApplyDamage(Gear, CurrentHedgehog, dmg, dsFall); |
|
6581 | 390 |
end |
391 |
end; |
|
392 |
||
393 |
||
394 |
procedure CalcRotationDirAngle(Gear: PGear); |
|
8330 | 395 |
var |
6581 | 396 |
dAngle: real; |
397 |
begin |
|
7825 | 398 |
// Frac/Round to be kind to JS as of 2012-08-27 where there is yet no int64/uint64 |
399 |
//dAngle := (Gear^.dX.QWordValue + Gear^.dY.QWordValue) / $80000000; |
|
400 |
dAngle := (Gear^.dX.Round + Gear^.dY.Round) / 2 + (Gear^.dX.Frac/$100000000+Gear^.dY.Frac/$100000000); |
|
6581 | 401 |
if not Gear^.dX.isNegative then |
402 |
Gear^.DirAngle := Gear^.DirAngle + dAngle |
|
403 |
else |
|
404 |
Gear^.DirAngle := Gear^.DirAngle - dAngle; |
|
405 |
||
406 |
if Gear^.DirAngle < 0 then |
|
407 |
Gear^.DirAngle := Gear^.DirAngle + 360 |
|
408 |
else if 360 < Gear^.DirAngle then |
|
409 |
Gear^.DirAngle := Gear^.DirAngle - 360 |
|
410 |
end; |
|
411 |
||
10363 | 412 |
procedure AddSplashForGear(Gear: PGear; justSkipping: boolean); |
413 |
var x, y, i, distL, distR, distB, minDist, maxDrops: LongInt; |
|
414 |
splash, particle: PVisualGear; |
|
415 |
speed, hwTmp: hwFloat; |
|
416 |
vi, vs, tmp: real; // impact speed and sideways speed |
|
417 |
isImpactH, isImpactRight: boolean; |
|
10419 | 418 |
const dist2surf = 4; |
10363 | 419 |
begin |
420 |
x:= hwRound(Gear^.X); |
|
421 |
y:= hwRound(Gear^.Y); |
|
422 |
||
10419 | 423 |
// find position for splash and impact speed |
10363 | 424 |
|
425 |
distB:= cWaterline - y; |
|
426 |
||
427 |
if WorldEdge <> weSea then |
|
428 |
minDist:= distB |
|
429 |
else |
|
430 |
begin |
|
431 |
distL:= x - leftX; |
|
432 |
distR:= rightX - x; |
|
433 |
minDist:= min(distB, min(distL, distR)); |
|
434 |
end; |
|
435 |
||
436 |
isImpactH:= (minDist <> distB); |
|
437 |
||
438 |
if not isImpactH then |
|
439 |
begin |
|
10417 | 440 |
y:= cWaterline - dist2surf; |
10363 | 441 |
speed:= hwAbs(Gear^.dY); |
442 |
end |
|
443 |
else |
|
444 |
begin |
|
445 |
isImpactRight := minDist = distR; |
|
446 |
if isImpactRight then |
|
10419 | 447 |
x:= rightX - dist2surf |
10363 | 448 |
else |
10419 | 449 |
x:= leftX + dist2surf; |
10363 | 450 |
speed:= hwAbs(Gear^.dX); |
451 |
end; |
|
452 |
||
453 |
// splash sound |
|
454 |
||
455 |
if justSkipping then |
|
456 |
PlaySound(sndSkip) |
|
457 |
else |
|
458 |
begin |
|
459 |
// adjust water impact sound based on gear speed and density |
|
460 |
hwTmp:= hwAbs(Gear^.Density * speed); |
|
461 |
||
462 |
if hwTmp > _1 then |
|
463 |
PlaySound(sndSplash) |
|
464 |
else if hwTmp > _0_5 then |
|
465 |
PlaySound(sndSkip) |
|
466 |
else |
|
467 |
PlaySound(sndDroplet2); |
|
468 |
end; |
|
469 |
||
10419 | 470 |
|
471 |
// splash visuals |
|
472 |
||
473 |
if ((cReducedQuality and rqPlainSplash) <> 0) then |
|
474 |
exit; |
|
475 |
||
476 |
splash:= AddVisualGear(x, y, vgtSplash); |
|
477 |
if splash = nil then |
|
478 |
exit; |
|
479 |
||
480 |
if not isImpactH then |
|
481 |
vs:= abs(hwFloat2Float(Gear^.dX)) |
|
482 |
else |
|
483 |
begin |
|
484 |
if isImpactRight then |
|
485 |
splash^.Angle:= -90 |
|
486 |
else |
|
487 |
splash^.Angle:= 90; |
|
488 |
vs:= abs(hwFloat2Float(Gear^.dY)); |
|
489 |
end; |
|
490 |
||
491 |
||
492 |
vi:= hwFloat2Float(speed); |
|
493 |
||
10363 | 494 |
with splash^ do |
495 |
begin |
|
496 |
Scale:= abs(hwFloat2Float(Gear^.Density / _3 * speed)); |
|
497 |
if Scale > 1 then Scale:= power(Scale,0.3333) |
|
498 |
else Scale:= Scale + ((1-Scale) / 2); |
|
499 |
if Scale > 1 then Timer:= round(min(Scale*0.0005/cGravityf,4)) |
|
500 |
else Timer:= 1; |
|
501 |
// Low Gravity |
|
502 |
FrameTicks:= FrameTicks*Timer; |
|
503 |
end; |
|
504 |
||
505 |
||
506 |
// eject water drops |
|
507 |
||
508 |
maxDrops := (hwRound(Gear^.Density) * 3) div 2 + round((vi + vs) * hwRound(Gear^.Density) * 6); |
|
509 |
for i:= max(maxDrops div 3, min(32, Random(maxDrops))) downto 0 do |
|
510 |
begin |
|
511 |
if isImpactH then |
|
512 |
particle := AddVisualGear(x, y - 3 + Random(7), vgtDroplet) |
|
513 |
else |
|
514 |
particle := AddVisualGear(x - 3 + Random(7), y, vgtDroplet); |
|
515 |
||
516 |
if particle <> nil then |
|
517 |
with particle^ do |
|
518 |
begin |
|
519 |
// dX and dY were initialized to have a random value on creation (see uVisualGearsList) |
|
520 |
if isImpactH then |
|
521 |
begin |
|
522 |
tmp:= dX; |
|
523 |
if isImpactRight then |
|
524 |
dX:= dY - vi / 5 |
|
525 |
else |
|
526 |
dX:= -dy + vi / 5; |
|
527 |
dY:= tmp * (1 + vs / 10); |
|
528 |
end |
|
529 |
else |
|
530 |
begin |
|
531 |
dX:= dX * (1 + vs / 10); |
|
532 |
dY:= dY - vi / 5; |
|
533 |
end; |
|
534 |
||
535 |
if splash <> nil then |
|
536 |
begin |
|
537 |
if splash^.Scale > 1 then |
|
538 |
begin |
|
539 |
dX:= dX * power(splash^.Scale, 0.3333); // tone down the droplet height further |
|
540 |
dY:= dY * power(splash^.Scale, 0.3333); |
|
541 |
end |
|
542 |
else |
|
543 |
begin |
|
544 |
dX:= dX * splash^.Scale; |
|
545 |
dY:= dY * splash^.Scale; |
|
546 |
end; |
|
547 |
end; |
|
548 |
end |
|
549 |
end; |
|
550 |
||
551 |
end; |
|
552 |
||
10354 | 553 |
procedure DrownGear(Gear: PGear); |
554 |
begin |
|
555 |
Gear^.doStep := @doStepDrowningGear; |
|
556 |
||
557 |
Gear^.Timer := 5000; // how long game should wait |
|
558 |
end; |
|
559 |
||
8947
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8763
diff
changeset
|
560 |
function CheckGearDrowning(var Gear: PGear): boolean; |
10015 | 561 |
var |
10363 | 562 |
skipSpeed, skipAngle, skipDecay: hwFloat; |
563 |
tmp, X, Y, dist2Water: LongInt; |
|
564 |
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
|
565 |
s: ansistring; |
6581 | 566 |
begin |
567 |
// probably needs tweaking. might need to be in a case statement based upon gear type |
|
10354 | 568 |
X:= hwRound(Gear^.X); |
6581 | 569 |
Y:= hwRound(Gear^.Y); |
10354 | 570 |
|
571 |
dist2Water:= cWaterLine - (Y + Gear^.Radius); |
|
10363 | 572 |
isDirH:= false; |
10354 | 573 |
|
574 |
if WorldEdge = weSea then |
|
6581 | 575 |
begin |
10363 | 576 |
tmp:= dist2Water; |
10494 | 577 |
dist2Water:= min(dist2Water, min(X - Gear^.Radius - LongInt(leftX), LongInt(rightX) - (X + Gear^.Radius))); |
10363 | 578 |
// if water on sides is closer than on bottom -> horizontal direction |
579 |
isDirH:= tmp <> dist2Water; |
|
10354 | 580 |
end; |
581 |
||
10363 | 582 |
isImpact:= false; |
583 |
||
10354 | 584 |
if dist2Water < 0 then |
585 |
begin |
|
586 |
// invisible gears will just be deleted |
|
587 |
// 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
|
588 |
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
|
589 |
begin |
7406
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7389
diff
changeset
|
590 |
if Gear^.Kind = gtGenericFaller then |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7389
diff
changeset
|
591 |
begin |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7389
diff
changeset
|
592 |
Gear^.X:= int2hwFloat(GetRandom(rightX-leftX)+leftX); |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7389
diff
changeset
|
593 |
Gear^.Y:= int2hwFloat(GetRandom(LAND_HEIGHT-topY)+topY); |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7389
diff
changeset
|
594 |
Gear^.dX:= _90-(GetRandomf*_360); |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7389
diff
changeset
|
595 |
Gear^.dY:= _90-(GetRandomf*_360) |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7389
diff
changeset
|
596 |
end |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7389
diff
changeset
|
597 |
else DeleteGear(Gear); |
10245 | 598 |
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
|
599 |
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
|
600 |
isSubmersible:= ((Gear = CurrentHedgehog^.Gear) and (CurAmmoGear <> nil) and (CurAmmoGear^.State and gstSubmersible <> 0)) or (Gear^.State and gstSubmersible <> 0); |
10363 | 601 |
|
6581 | 602 |
skipSpeed := _0_25; |
603 |
skipAngle := _1_9; |
|
604 |
skipDecay := _0_87; |
|
10363 | 605 |
|
10354 | 606 |
|
607 |
// skipping |
|
608 |
||
10512
25021aac078e
fix underwater-skipping bug and make air-strike missiles submersible when fired from within weSea
sheepluva
parents:
10508
diff
changeset
|
609 |
if (not isSubmersible) and (hwSqr(Gear^.dX) + hwSqr(Gear^.dY) > skipSpeed) |
10363 | 610 |
and ( ((not isDirH) and (hwAbs(Gear^.dX) > skipAngle * hwAbs(Gear^.dY))) |
611 |
or (isDirH and (hwAbs(Gear^.dY) > skipAngle * hwAbs(Gear^.dX))) ) then |
|
6581 | 612 |
begin |
10363 | 613 |
isSkip:= true; |
10354 | 614 |
// if skipping we move the gear out of water |
10363 | 615 |
if isDirH then |
10354 | 616 |
begin |
617 |
Gear^.dX.isNegative := (not Gear^.dX.isNegative); |
|
618 |
Gear^.X:= Gear^.X + Gear^.dX; |
|
619 |
end |
|
620 |
else |
|
621 |
begin |
|
622 |
Gear^.dY.isNegative := (not Gear^.dY.isNegative); |
|
623 |
Gear^.Y:= Gear^.Y + Gear^.dY; |
|
624 |
end; |
|
6581 | 625 |
Gear^.dY := Gear^.dY * skipDecay; |
626 |
Gear^.dX := Gear^.dX * skipDecay; |
|
627 |
CheckGearDrowning := false; |
|
628 |
end |
|
10354 | 629 |
else // not skipping |
6581 | 630 |
begin |
10363 | 631 |
isImpact:= true; |
632 |
isSkip:= false; |
|
6581 | 633 |
if not isSubmersible then |
634 |
begin |
|
635 |
CheckGearDrowning := true; |
|
636 |
Gear^.State := gstDrowning; |
|
637 |
Gear^.RenderTimer := false; |
|
638 |
if (Gear^.Kind <> gtSniperRifleShot) and (Gear^.Kind <> gtShotgunShot) |
|
639 |
and (Gear^.Kind <> gtDEagleShot) and (Gear^.Kind <> gtSineGunShot) then |
|
640 |
if Gear^.Kind = gtHedgehog then |
|
641 |
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
|
642 |
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
|
643 |
begin |
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8763
diff
changeset
|
644 |
// 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
|
645 |
ResurrectHedgehog(Gear); |
10245 | 646 |
exit(true) |
8947
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8763
diff
changeset
|
647 |
end |
6581 | 648 |
else |
649 |
begin |
|
10354 | 650 |
DrownGear(Gear); |
6581 | 651 |
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
|
652 |
s:= ansistring(Gear^.Hedgehog^.Name); |
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10116
diff
changeset
|
653 |
AddCaption(FormatA(GetEventString(eidDrowned), s), cWhiteColor, capgrpMessage); |
6581 | 654 |
end |
655 |
end |
|
656 |
else |
|
10354 | 657 |
DrownGear(Gear); |
10419 | 658 |
if Gear^.Kind = gtFlake then |
10354 | 659 |
exit(true); // skip splashes |
8990 | 660 |
end |
10363 | 661 |
else // submersible |
662 |
begin |
|
663 |
// drown submersible grears if far below map |
|
664 |
if (Y > cWaterLine + cVisibleWater*4) then |
|
665 |
begin |
|
666 |
DrownGear(Gear); |
|
667 |
exit(true); // no splashes needed |
|
668 |
end; |
|
10354 | 669 |
|
10363 | 670 |
CheckGearDrowning := false; |
671 |
||
672 |
// check if surface was penetrated |
|
10354 | 673 |
|
10363 | 674 |
// no penetration if center's water distance not smaller than radius |
675 |
if abs(dist2Water + Gear^.Radius) >= Gear^.Radius then |
|
676 |
isImpact:= false |
|
6804 | 677 |
else |
10354 | 678 |
begin |
10363 | 679 |
// get distance to water of last tick |
680 |
if isDirH then |
|
681 |
begin |
|
682 |
tmp:= hwRound(Gear^.X - Gear^.dX); |
|
683 |
tmp:= abs(min(tmp - leftX, rightX - tmp)); |
|
684 |
end |
|
10354 | 685 |
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
|
686 |
begin |
10363 | 687 |
tmp:= hwRound(Gear^.Y - Gear^.dY); |
688 |
tmp:= abs(cWaterLine - tmp); |
|
689 |
end; |
|
10354 | 690 |
|
10419 | 691 |
// there was an impact if distance was >= radius |
692 |
isImpact:= (tmp >= Gear^.Radius) |
|
10363 | 693 |
end; |
694 |
end; // end of submersible |
|
695 |
end; // end of not skipping |
|
696 |
||
697 |
// splash sound animation and droplets |
|
698 |
if isImpact or isSkip then |
|
699 |
addSplashForGear(Gear, isSkip); |
|
700 |
||
10668 | 701 |
if isSkip then |
702 |
ScriptCall('onGearWaterSkip', Gear^.uid); |
|
6581 | 703 |
end |
704 |
else |
|
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
705 |
begin |
9521
8054d9d775fd
merge with latest defaul, fixing compiling with fpc, parsing and rendering with pas2c, some minor problems with compiling with clang
koda
diff
changeset
|
706 |
if (not ((Gear^.Kind = gtJetpack) or (Gear^.Kind = gtBee))) then |
8054d9d775fd
merge with latest defaul, fixing compiling with fpc, parsing and rendering with pas2c, some minor problems with compiling with clang
koda
diff
changeset
|
707 |
Gear^.State:= (Gear^.State and (not gstSubmersible)); // making it temporary for most gears is more attractive I think |
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
708 |
CheckGearDrowning := false |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
709 |
end |
6581 | 710 |
end; |
711 |
||
712 |
||
8947
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8763
diff
changeset
|
713 |
procedure ResurrectHedgehog(var gear: PGear); |
6581 | 714 |
var tempTeam : PTeam; |
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
|
715 |
sparkles: PVisualGear; |
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
|
716 |
gX, gY: LongInt; |
6581 | 717 |
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
|
718 |
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
|
719 |
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
|
720 |
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
|
721 |
uStats.HedgehogDamaged(Gear, CurrentHedgehog, 0, true); |
6581 | 722 |
AttackBar:= 0; |
723 |
gear^.dX := _0; |
|
724 |
gear^.dY := _0; |
|
725 |
gear^.Damage := 0; |
|
726 |
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
|
727 |
gear^.Hedgehog^.Effects[hePoisoned] := 0; |
7176
fb4b0c6dfdbd
Make watching AI v AI on ai survival a bit more entertaining
nemo
parents:
7168
diff
changeset
|
728 |
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
|
729 |
and (Gear^.Hedgehog^.Team^.Clan <> CurrentHedgehog^.Team^.Clan)) then |
8330 | 730 |
with CurrentHedgehog^ do |
6581 | 731 |
begin |
732 |
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
|
733 |
FreeAndNilTexture(Team^.AIKillsTex); |
10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10116
diff
changeset
|
734 |
Team^.AIKillsTex := RenderStringTex(ansistring(inttostr(Team^.stats.AIKills)), Team^.Clan^.Color, fnt16); |
6581 | 735 |
end; |
736 |
tempTeam := gear^.Hedgehog^.Team; |
|
737 |
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
|
738 |
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
|
739 |
gY := hwRound(gear^.Y); |
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
|
740 |
// might need more sparkles for a column |
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
|
741 |
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
|
742 |
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
|
743 |
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
|
744 |
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
|
745 |
//sparkles^.Angle:= random(360); |
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
|
746 |
end; |
8330 | 747 |
FindPlace(gear, false, 0, LAND_WIDTH, true); |
6581 | 748 |
if gear <> nil then |
749 |
begin |
|
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
|
750 |
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
|
751 |
PlaySound(sndWarp); |
6581 | 752 |
RenderHealth(gear^.Hedgehog^); |
753 |
ScriptCall('onGearResurrect', gear^.uid); |
|
754 |
gear^.State := gstWait; |
|
8947
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning -> ResurrectHedgehog -> FindPlace). Fixes bug 620.
unc0rr
parents:
8763
diff
changeset
|
755 |
end; |
6581 | 756 |
RecountTeamHealth(tempTeam); |
757 |
end; |
|
758 |
||
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
|
759 |
function CountNonZeroz(x, y, r, c: LongInt; mask: LongWord): LongInt; |
6581 | 760 |
var i: LongInt; |
761 |
count: LongInt = 0; |
|
762 |
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
|
763 |
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
|
764 |
for i:= max(x - r, 0) to min(x + r, LAND_WIDTH - 1) do |
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
|
765 |
if Land[y, i] and mask <> 0 then |
6581 | 766 |
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
|
767 |
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
|
768 |
if count = c then |
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
|
769 |
begin |
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
|
770 |
CountNonZeroz:= 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
|
771 |
exit |
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
|
772 |
end; |
6581 | 773 |
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
|
774 |
CountNonZeroz:= count; |
6581 | 775 |
end; |
776 |
||
10272
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
777 |
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
|
778 |
var cnt, i: LongInt; |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
779 |
begin |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
780 |
cnt:= 0; |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
781 |
isSteadyPosition:= false; |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
782 |
|
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
783 |
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
|
784 |
begin |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
785 |
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
|
786 |
begin |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
787 |
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
|
788 |
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
|
789 |
|
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
790 |
if cnt >= c then |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
791 |
begin |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
792 |
isSteadyPosition:= true; |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
793 |
exit |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
794 |
end; |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
795 |
end; |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
796 |
end; |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
797 |
end; |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
798 |
|
6888 | 799 |
|
800 |
function NoGearsToAvoid(mX, mY: LongInt; rX, rY: LongInt): boolean; |
|
801 |
var t: PGear; |
|
802 |
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
|
803 |
NoGearsToAvoid:= false; |
6888 | 804 |
t:= GearsList; |
805 |
rX:= sqr(rX); |
|
806 |
rY:= sqr(rY); |
|
807 |
while t <> nil do |
|
808 |
begin |
|
809 |
if t^.Kind <= gtExplosives then |
|
810 |
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
|
811 |
exit; |
6888 | 812 |
t:= t^.NextGear |
813 |
end; |
|
814 |
NoGearsToAvoid:= true |
|
815 |
end; |
|
816 |
||
6986
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6888
diff
changeset
|
817 |
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
|
818 |
begin |
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6888
diff
changeset
|
819 |
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
|
820 |
end; |
6888 | 821 |
|
6581 | 822 |
procedure FindPlace(var Gear: PGear; withFall: boolean; Left, Right: LongInt; skipProximity: boolean); |
823 |
var x: LongInt; |
|
824 |
y, sy: LongInt; |
|
8007 | 825 |
ar: array[0..1023] of TPoint; |
826 |
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
|
827 |
temp: TPoint; |
6581 | 828 |
cnt, cnt2: Longword; |
829 |
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
|
830 |
ignoreNearObjects, ignoreOverlap, tryAgain: boolean; |
6581 | 831 |
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
|
832 |
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
|
833 |
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 | 834 |
tryAgain:= true; |
10015 | 835 |
if WorldEdge <> weNone then |
9477 | 836 |
begin |
9809 | 837 |
Left:= max(Left, LongInt(leftX) + Gear^.Radius); |
9477 | 838 |
Right:= min(Right,rightX-Gear^.Radius) |
839 |
end; |
|
6581 | 840 |
while tryAgain do |
841 |
begin |
|
8007 | 842 |
delta:= LAND_WIDTH div 16; |
6581 | 843 |
cnt2:= 0; |
844 |
repeat |
|
8007 | 845 |
x:= Left + max(LAND_WIDTH div 2048, LongInt(GetRandom(Delta))); |
6581 | 846 |
repeat |
847 |
inc(x, Delta); |
|
848 |
cnt:= 0; |
|
9809 | 849 |
y:= min(1024, topY) - Gear^.Radius shl 1; |
6581 | 850 |
while y < cWaterLine do |
851 |
begin |
|
852 |
repeat |
|
853 |
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
|
854 |
until (y >= cWaterLine) or |
10015 | 855 |
((not ignoreOverlap) and (CountNonZeroz(x, y, Gear^.Radius - 1, 1, $FFFF) = 0)) or |
8751
4609823efc94
More flagging of Land values. Also use less than for tests of non-terrain, instead of "and $FF00 = 0". Saves a couple of ops, which actually matters a small amount in a few places.
nemo
parents:
8632
diff
changeset
|
856 |
(ignoreOverlap and (CountNonZeroz(x, y, Gear^.Radius - 1, 1, lfLandMask) = 0)); |
6581 | 857 |
|
858 |
sy:= y; |
|
859 |
||
860 |
repeat |
|
861 |
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
|
862 |
until (y >= cWaterLine) or |
10015 | 863 |
((not ignoreOverlap) and (CountNonZeroz(x, y, Gear^.Radius - 1, 1, $FFFF) <> 0)) or |
864 |
(ignoreOverlap and (CountNonZeroz(x, y, Gear^.Radius - 1, 1, lfLandMask) <> 0)); |
|
6581 | 865 |
|
10272
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
866 |
if (y - sy > Gear^.Radius * 2) and (y < cWaterLine) |
6581 | 867 |
and (((Gear^.Kind = gtExplosives) |
10272
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
868 |
and (ignoreNearObjects or NoGearsToAvoid(x, y - Gear^.Radius, 60, 60)) |
10274 | 869 |
and (isSteadyPosition(x, y+1, Gear^.Radius - 1, 3, $FFFF) |
870 |
or (CountNonZeroz(x, y+1, Gear^.Radius - 1, Gear^.Radius+1, $FFFF) > Gear^.Radius) |
|
871 |
)) |
|
10272
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
872 |
or |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
873 |
((Gear^.Kind <> gtExplosives) |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
874 |
and (ignoreNearObjects or NoGearsToAvoid(x, y - Gear^.Radius, 110, 110)) |
31ee88c9b4d0
Allow barrels to spawn in U-shaped pits in stable position
unc0rr
parents:
10245
diff
changeset
|
875 |
)) then |
6888 | 876 |
begin |
6581 | 877 |
ar[cnt].X:= x; |
878 |
if withFall then |
|
879 |
ar[cnt].Y:= sy + Gear^.Radius |
|
880 |
else |
|
881 |
ar[cnt].Y:= y - Gear^.Radius; |
|
882 |
inc(cnt) |
|
883 |
end; |
|
884 |
||
7603
e9c3c67b5dfd
reducing this value is sufficient to ensure crates drop just below top border or a girder
nemo
parents:
7599
diff
changeset
|
885 |
inc(y, 10) |
6581 | 886 |
end; |
887 |
||
888 |
if cnt > 0 then |
|
10015 | 889 |
begin |
890 |
temp := ar[GetRandom(cnt)]; |
|
891 |
with temp do |
|
6581 | 892 |
begin |
893 |
ar2[cnt2].x:= x; |
|
894 |
ar2[cnt2].y:= y; |
|
895 |
inc(cnt2) |
|
896 |
end |
|
10015 | 897 |
end |
6581 | 898 |
until (x + Delta > Right); |
899 |
||
900 |
dec(Delta, 60) |
|
901 |
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
|
902 |
// 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
|
903 |
if (cnt2 = 0) and skipProximity and (not ignoreOverlap) then |
6581 | 904 |
tryAgain:= true |
905 |
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
|
906 |
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
|
907 |
ignoreNearObjects:= true; |
6581 | 908 |
end; |
909 |
||
910 |
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
|
911 |
begin |
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
8007
diff
changeset
|
912 |
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
|
913 |
with temp do |
6581 | 914 |
begin |
915 |
Gear^.X:= int2hwFloat(x); |
|
916 |
Gear^.Y:= int2hwFloat(y); |
|
917 |
AddFileLog('Assigned Gear coordinates (' + inttostr(x) + ',' + inttostr(y) + ')'); |
|
918 |
end |
|
8026
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
8007
diff
changeset
|
919 |
end |
6581 | 920 |
else |
921 |
begin |
|
922 |
OutError('Can''t find place for Gear', false); |
|
923 |
if Gear^.Kind = gtHedgehog then |
|
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
|
924 |
Gear^.Hedgehog^.Effects[heResurrectable] := 0; |
6581 | 925 |
DeleteGear(Gear); |
926 |
Gear:= nil |
|
927 |
end |
|
928 |
end; |
|
929 |
||
930 |
function CheckGearNear(Gear: PGear; Kind: TGearType; rX, rY: LongInt): PGear; |
|
931 |
var t: PGear; |
|
932 |
begin |
|
933 |
t:= GearsList; |
|
934 |
rX:= sqr(rX); |
|
935 |
rY:= sqr(rY); |
|
936 |
||
937 |
while t <> nil do |
|
938 |
begin |
|
939 |
if (t <> Gear) and (t^.Kind = Kind) then |
|
940 |
if not((hwSqr(Gear^.X - t^.X) / rX + hwSqr(Gear^.Y - 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
|
941 |
begin |
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
|
942 |
CheckGearNear:= t; |
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
|
943 |
exit; |
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
|
944 |
end; |
6581 | 945 |
t:= t^.NextGear |
946 |
end; |
|
947 |
||
948 |
CheckGearNear:= nil |
|
949 |
end; |
|
950 |
||
7592 | 951 |
procedure CheckCollision(Gear: PGear); inline; |
952 |
begin |
|
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
953 |
if (TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) <> 0) |
7592 | 954 |
or (TestCollisionYwithGear(Gear, hwSign(Gear^.dY)) <> 0) then |
955 |
Gear^.State := Gear^.State or gstCollision |
|
956 |
else |
|
957 |
Gear^.State := Gear^.State and (not gstCollision) |
|
958 |
end; |
|
959 |
||
960 |
procedure CheckCollisionWithLand(Gear: PGear); inline; |
|
961 |
begin |
|
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
962 |
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
|
963 |
or (TestCollisionY(Gear, hwSign(Gear^.dY)) <> 0) then |
7592 | 964 |
Gear^.State := Gear^.State or gstCollision |
8330 | 965 |
else |
7592 | 966 |
Gear^.State := Gear^.State and (not gstCollision) |
967 |
end; |
|
968 |
||
7719
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
969 |
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
|
970 |
begin |
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
971 |
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
|
972 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
973 |
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
|
974 |
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
|
975 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
976 |
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
|
977 |
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
|
978 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
979 |
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
|
980 |
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
|
981 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
982 |
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
|
983 |
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
|
984 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
985 |
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
|
986 |
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
|
987 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
988 |
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
|
989 |
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
|
990 |
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
|
991 |
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
|
992 |
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
|
993 |
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
|
994 |
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
|
995 |
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
|
996 |
end; |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
997 |
|
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
998 |
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
|
999 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1000 |
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
|
1001 |
MakeHedgehogsStep:= true |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1002 |
end else |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1003 |
MakeHedgehogsStep:= false; |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1004 |
|
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1005 |
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
|
1006 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1007 |
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
|
1008 |
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
|
1009 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1010 |
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
|
1011 |
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
|
1012 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1013 |
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
|
1014 |
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
|
1015 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1016 |
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
|
1017 |
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
|
1018 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1019 |
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
|
1020 |
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
|
1021 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1022 |
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
|
1023 |
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
|
1024 |
begin |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1025 |
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
|
1026 |
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
|
1027 |
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
|
1028 |
exit |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1029 |
end; |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1030 |
end |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1031 |
end |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1032 |
end |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1033 |
end |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1034 |
end |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1035 |
end; |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1036 |
end; |
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7627
diff
changeset
|
1037 |
|
9285 | 1038 |
|
1039 |
procedure ShotgunShot(Gear: PGear); |
|
1040 |
var t: PGear; |
|
1041 |
dmg, r, dist: LongInt; |
|
1042 |
dx, dy: hwFloat; |
|
1043 |
begin |
|
1044 |
Gear^.Radius:= cShotgunRadius; |
|
1045 |
t:= GearsList; |
|
1046 |
while t <> nil do |
|
1047 |
begin |
|
1048 |
case t^.Kind of |
|
1049 |
gtHedgehog, |
|
1050 |
gtMine, |
|
1051 |
gtSMine, |
|
1052 |
gtKnife, |
|
1053 |
gtCase, |
|
1054 |
gtTarget, |
|
1055 |
gtExplosives: begin//, |
|
1056 |
// gtStructure: begin |
|
1057 |
//addFileLog('ShotgunShot radius: ' + inttostr(Gear^.Radius) + ', t^.Radius = ' + inttostr(t^.Radius) + ', distance = ' + inttostr(dist) + ', dmg = ' + inttostr(dmg)); |
|
1058 |
dmg:= 0; |
|
1059 |
r:= Gear^.Radius + t^.Radius; |
|
1060 |
dx:= Gear^.X-t^.X; |
|
1061 |
dx.isNegative:= false; |
|
1062 |
dy:= Gear^.Y-t^.Y; |
|
1063 |
dy.isNegative:= false; |
|
1064 |
if r-hwRound(dx+dy) > 0 then |
|
1065 |
begin |
|
1066 |
dist:= hwRound(Distance(dx, dy)); |
|
1067 |
dmg:= ModifyDamage(min(r - dist, 25), t); |
|
1068 |
end; |
|
1069 |
if dmg > 0 then |
|
1070 |
begin |
|
10558 | 1071 |
if (t^.Kind <> gtHedgehog) or (t^.Hedgehog^.Effects[heInvulnerable] = 0) then |
9285 | 1072 |
ApplyDamage(t, Gear^.Hedgehog, dmg, dsBullet) |
1073 |
else |
|
1074 |
Gear^.State:= Gear^.State or gstWinner; |
|
1075 |
||
1076 |
DeleteCI(t); |
|
1077 |
t^.dX:= t^.dX + Gear^.dX * dmg * _0_01 + SignAs(cHHKick, Gear^.dX); |
|
1078 |
t^.dY:= t^.dY + Gear^.dY * dmg * _0_01; |
|
1079 |
t^.State:= t^.State or gstMoving; |
|
1080 |
if t^.Kind = gtKnife then t^.State:= t^.State and (not gstCollision); |
|
1081 |
t^.Active:= true; |
|
1082 |
FollowGear:= t |
|
1083 |
end |
|
1084 |
end; |
|
1085 |
gtGrave: begin |
|
1086 |
dmg:= 0; |
|
1087 |
r:= Gear^.Radius + t^.Radius; |
|
1088 |
dx:= Gear^.X-t^.X; |
|
1089 |
dx.isNegative:= false; |
|
1090 |
dy:= Gear^.Y-t^.Y; |
|
1091 |
dy.isNegative:= false; |
|
1092 |
if r-hwRound(dx+dy) > 0 then |
|
1093 |
begin |
|
1094 |
dist:= hwRound(Distance(dx, dy)); |
|
1095 |
dmg:= ModifyDamage(min(r - dist, 25), t); |
|
1096 |
end; |
|
1097 |
if dmg > 0 then |
|
1098 |
begin |
|
1099 |
t^.dY:= - _0_1; |
|
1100 |
t^.Active:= true |
|
1101 |
end |
|
1102 |
end; |
|
1103 |
end; |
|
1104 |
t:= t^.NextGear |
|
1105 |
end; |
|
1106 |
if (GameFlags and gfSolidLand) = 0 then |
|
1107 |
DrawExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), cShotgunRadius) |
|
1108 |
end; |
|
1109 |
||
1110 |
procedure AmmoShove(Ammo: PGear; Damage, Power: LongInt); |
|
1111 |
var t: PGearArray; |
|
1112 |
Gear: PGear; |
|
1113 |
i, j, tmpDmg: LongInt; |
|
1114 |
VGear: PVisualGear; |
|
1115 |
begin |
|
1116 |
t:= CheckGearsCollision(Ammo); |
|
1117 |
// Just to avoid hogs on rope dodging fire. |
|
1118 |
if (CurAmmoGear <> nil) and ((CurAmmoGear^.Kind = gtRope) or (CurAmmoGear^.Kind = gtJetpack) or (CurAmmoGear^.Kind = gtBirdy)) |
|
1119 |
and (CurrentHedgehog^.Gear <> nil) and (CurrentHedgehog^.Gear^.CollisionIndex = -1) |
|
1120 |
and (sqr(hwRound(Ammo^.X) - hwRound(CurrentHedgehog^.Gear^.X)) + sqr(hwRound(Ammo^.Y) - hwRound(CurrentHedgehog^.Gear^.Y)) <= sqr(cHHRadius + Ammo^.Radius)) then |
|
1121 |
begin |
|
1122 |
t^.ar[t^.Count]:= CurrentHedgehog^.Gear; |
|
1123 |
inc(t^.Count) |
|
1124 |
end; |
|
1125 |
||
1126 |
i:= t^.Count; |
|
1127 |
||
1128 |
if (Ammo^.Kind = gtFlame) and (i > 0) then |
|
1129 |
Ammo^.Health:= 0; |
|
1130 |
while i > 0 do |
|
1131 |
begin |
|
1132 |
dec(i); |
|
1133 |
Gear:= t^.ar[i]; |
|
10015 | 1134 |
if ((Ammo^.Kind = gtFlame) or (Ammo^.Kind = gtBlowTorch)) and |
9285 | 1135 |
(Gear^.Kind = gtHedgehog) and (Gear^.Hedgehog^.Effects[heFrozen] > 255) then |
1136 |
Gear^.Hedgehog^.Effects[heFrozen]:= max(255,Gear^.Hedgehog^.Effects[heFrozen]-10000); |
|
1137 |
tmpDmg:= ModifyDamage(Damage, Gear); |
|
1138 |
if (Gear^.State and gstNoDamage) = 0 then |
|
1139 |
begin |
|
1140 |
||
10015 | 1141 |
if (Ammo^.Kind = gtDEagleShot) or (Ammo^.Kind = gtSniperRifleShot) then |
9285 | 1142 |
begin |
1143 |
VGear := AddVisualGear(hwround(Ammo^.X), hwround(Ammo^.Y), vgtBulletHit); |
|
1144 |
if VGear <> nil then |
|
1145 |
VGear^.Angle := DxDy2Angle(-Ammo^.dX, Ammo^.dY); |
|
1146 |
end; |
|
1147 |
||
1148 |
if (Gear^.Kind = gtHedgehog) and (Ammo^.State and gsttmpFlag <> 0) and (Ammo^.Kind = gtShover) then |
|
1149 |
Gear^.FlightTime:= 1; |
|
1150 |
||
1151 |
||
1152 |
case Gear^.Kind of |
|
1153 |
gtHedgehog, |
|
1154 |
gtMine, |
|
1155 |
gtSMine, |
|
1156 |
gtKnife, |
|
1157 |
gtTarget, |
|
1158 |
gtCase, |
|
1159 |
gtExplosives: //, |
|
1160 |
//gtStructure: |
|
1161 |
begin |
|
1162 |
if (Ammo^.Kind = gtDrill) then |
|
1163 |
begin |
|
1164 |
Ammo^.Timer:= 0; |
|
1165 |
exit; |
|
1166 |
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
|
1167 |
if (Gear^.Kind <> gtHedgehog) or (Gear^.Hedgehog^.Effects[heInvulnerable] = 0) then |
9285 | 1168 |
begin |
1169 |
if (Ammo^.Kind = gtKnife) and (tmpDmg > 0) then |
|
1170 |
for j:= 1 to max(1,min(3,tmpDmg div 5)) do |
|
1171 |
begin |
|
1172 |
VGear:= AddVisualGear(hwRound(Ammo^.X-((Ammo^.X-Gear^.X)/_2)), hwRound(Ammo^.Y-((Ammo^.Y-Gear^.Y)/_2)), vgtStraightShot); |
|
1173 |
if VGear <> nil then |
|
1174 |
with VGear^ do |
|
1175 |
begin |
|
1176 |
Tint:= $FFCC00FF; |
|
1177 |
Angle:= random(360); |
|
1178 |
dx:= 0.0005 * (random(100)); |
|
1179 |
dy:= 0.0005 * (random(100)); |
|
1180 |
if random(2) = 0 then |
|
1181 |
dx := -dx; |
|
1182 |
if random(2) = 0 then |
|
1183 |
dy := -dy; |
|
1184 |
FrameTicks:= 600+random(200); |
|
1185 |
State:= ord(sprStar) |
|
1186 |
end |
|
1187 |
end; |
|
1188 |
ApplyDamage(Gear, Ammo^.Hedgehog, tmpDmg, dsShove) |
|
1189 |
end |
|
1190 |
else |
|
1191 |
Gear^.State:= Gear^.State or gstWinner; |
|
10015 | 1192 |
if (Gear^.Kind = gtExplosives) and (Ammo^.Kind = gtBlowtorch) then |
9285 | 1193 |
begin |
1194 |
if (Ammo^.Hedgehog^.Gear <> nil) then |
|
1195 |
Ammo^.Hedgehog^.Gear^.State:= Ammo^.Hedgehog^.Gear^.State and (not gstNotKickable); |
|
1196 |
ApplyDamage(Gear, Ammo^.Hedgehog, tmpDmg * 100, dsUnknown); // crank up damage for explosives + blowtorch |
|
1197 |
end; |
|
1198 |
||
1199 |
if (Gear^.Kind = gtHedgehog) and (Gear^.Hedgehog^.King or (Gear^.Hedgehog^.Effects[heFrozen] > 0)) then |
|
1200 |
begin |
|
1201 |
Gear^.dX:= Ammo^.dX * Power * _0_005; |
|
1202 |
Gear^.dY:= Ammo^.dY * Power * _0_005 |
|
1203 |
end |
|
1204 |
else if ((Ammo^.Kind <> gtFlame) or (Gear^.Kind = gtHedgehog)) and (Power <> 0) then |
|
1205 |
begin |
|
1206 |
Gear^.dX:= Ammo^.dX * Power * _0_01; |
|
1207 |
Gear^.dY:= Ammo^.dY * Power * _0_01 |
|
1208 |
end; |
|
1209 |
||
1210 |
if (not isZero(Gear^.dX)) or (not isZero(Gear^.dY)) then |
|
1211 |
begin |
|
1212 |
Gear^.Active:= true; |
|
1213 |
DeleteCI(Gear); |
|
1214 |
Gear^.State:= Gear^.State or gstMoving; |
|
1215 |
if Gear^.Kind = gtKnife then Gear^.State:= Gear^.State and (not gstCollision); |
|
1216 |
// 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
|
1217 |
if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) <> 0 then |
9285 | 1218 |
begin |
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset
|
1219 |
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
|
1220 |
(TestCollisionYwithGear(Gear, -1) = 0) then |
9285 | 1221 |
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
|
1222 |
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
|
1223 |
(TestCollisionYwithGear(Gear, -1) = 0) then |
9285 | 1224 |
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
|
1225 |
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
|
1226 |
(TestCollisionYwithGear(Gear, -1) = 0) then |
9285 | 1227 |
Gear^.Y:= Gear^.Y - _1; |
1228 |
end |
|
1229 |
end; |
|
1230 |
||
1231 |
||
1232 |
if (Ammo^.Kind <> gtFlame) or ((Ammo^.State and gsttmpFlag) = 0) then |
|
1233 |
FollowGear:= Gear |
|
1234 |
end; |
|
1235 |
end |
|
1236 |
end; |
|
1237 |
end; |
|
1238 |
if i <> 0 then |
|
1239 |
SetAllToActive |
|
1240 |
end; |
|
1241 |
||
1242 |
||
1243 |
function CountGears(Kind: TGearType): Longword; |
|
1244 |
var t: PGear; |
|
1245 |
count: Longword = 0; |
|
1246 |
begin |
|
1247 |
||
1248 |
t:= GearsList; |
|
1249 |
while t <> nil do |
|
1250 |
begin |
|
1251 |
if t^.Kind = Kind then |
|
1252 |
inc(count); |
|
1253 |
t:= t^.NextGear |
|
1254 |
end; |
|
1255 |
CountGears:= count; |
|
1256 |
end; |
|
1257 |
||
1258 |
procedure SetAllToActive; |
|
1259 |
var t: PGear; |
|
1260 |
begin |
|
1261 |
AllInactive:= false; |
|
1262 |
t:= GearsList; |
|
1263 |
while t <> nil do |
|
1264 |
begin |
|
1265 |
t^.Active:= true; |
|
1266 |
t:= t^.NextGear |
|
1267 |
end |
|
1268 |
end; |
|
1269 |
||
1270 |
procedure SetAllHHToActive; inline; |
|
1271 |
begin |
|
1272 |
SetAllHHToActive(true) |
|
1273 |
end; |
|
1274 |
||
1275 |
||
1276 |
procedure SetAllHHToActive(Ice: boolean); |
|
1277 |
var t: PGear; |
|
1278 |
begin |
|
1279 |
AllInactive:= false; |
|
1280 |
t:= GearsList; |
|
1281 |
while t <> nil do |
|
1282 |
begin |
|
1283 |
if (t^.Kind = gtHedgehog) or (t^.Kind = gtExplosives) then |
|
1284 |
begin |
|
1285 |
if (t^.Kind = gtHedgehog) and Ice then CheckIce(t); |
|
1286 |
t^.Active:= true |
|
1287 |
end; |
|
1288 |
t:= t^.NextGear |
|
1289 |
end |
|
1290 |
end; |
|
1291 |
||
1292 |
||
1293 |
var GearsNearArray : TPGearArray; |
|
1294 |
function GearsNear(X, Y: hwFloat; Kind: TGearType; r: LongInt): PGearArrayS; |
|
1295 |
var |
|
1296 |
t: PGear; |
|
1297 |
s: Longword; |
|
1298 |
begin |
|
1299 |
r:= r*r; |
|
1300 |
s:= 0; |
|
1301 |
SetLength(GearsNearArray, s); |
|
1302 |
t := GearsList; |
|
10015 | 1303 |
while t <> nil do |
9285 | 1304 |
begin |
10015 | 1305 |
if (t^.Kind = Kind) |
9285 | 1306 |
and ((X - t^.X)*(X - t^.X) + (Y - t^.Y)*(Y-t^.Y) < int2hwFloat(r)) then |
1307 |
begin |
|
1308 |
inc(s); |
|
1309 |
SetLength(GearsNearArray, s); |
|
1310 |
GearsNearArray[s - 1] := t; |
|
1311 |
end; |
|
1312 |
t := t^.NextGear; |
|
1313 |
end; |
|
1314 |
||
1315 |
GearsNear.size:= s; |
|
1316 |
GearsNear.ar:= @GearsNearArray |
|
1317 |
end; |
|
1318 |
||
1319 |
||
1320 |
procedure SpawnBoxOfSmth; |
|
1321 |
var t, aTot, uTot, a, h: LongInt; |
|
1322 |
i: TAmmoType; |
|
1323 |
begin |
|
1324 |
if (PlacingHogs) or |
|
1325 |
(cCaseFactor = 0) |
|
1326 |
or (CountGears(gtCase) >= 5) |
|
1327 |
or (GetRandom(cCaseFactor) <> 0) then |
|
1328 |
exit; |
|
1329 |
||
1330 |
FollowGear:= nil; |
|
1331 |
aTot:= 0; |
|
1332 |
uTot:= 0; |
|
1333 |
for i:= Low(TAmmoType) to High(TAmmoType) do |
|
1334 |
if (Ammoz[i].Ammo.Propz and ammoprop_Utility) = 0 then |
|
1335 |
inc(aTot, Ammoz[i].Probability) |
|
1336 |
else |
|
1337 |
inc(uTot, Ammoz[i].Probability); |
|
1338 |
||
1339 |
t:=0; |
|
1340 |
a:=aTot; |
|
1341 |
h:= 1; |
|
1342 |
||
1343 |
if (aTot+uTot) <> 0 then |
|
1344 |
if ((GameFlags and gfInvulnerable) = 0) then |
|
1345 |
begin |
|
1346 |
h:= cHealthCaseProb * 100; |
|
1347 |
t:= GetRandom(10000); |
|
1348 |
a:= (10000-h)*aTot div (aTot+uTot) |
|
1349 |
end |
|
1350 |
else |
|
1351 |
begin |
|
1352 |
t:= GetRandom(aTot+uTot); |
|
1353 |
h:= 0 |
|
1354 |
end; |
|
1355 |
||
1356 |
||
1357 |
if t<h then |
|
1358 |
begin |
|
1359 |
FollowGear:= AddGear(0, 0, gtCase, 0, _0, _0, 0); |
|
1360 |
FollowGear^.Health:= cHealthCaseAmount; |
|
1361 |
FollowGear^.Pos:= posCaseHealth; |
|
10506 | 1362 |
// health crate is smaller than the other crates |
1363 |
FollowGear^.Radius := cCaseHealthRadius; |
|
9285 | 1364 |
AddCaption(GetEventString(eidNewHealthPack), cWhiteColor, capgrpAmmoInfo); |
1365 |
end |
|
1366 |
else if (t<a+h) then |
|
1367 |
begin |
|
1368 |
t:= aTot; |
|
1369 |
if (t > 0) then |
|
1370 |
begin |
|
1371 |
FollowGear:= AddGear(0, 0, gtCase, 0, _0, _0, 0); |
|
1372 |
t:= GetRandom(t); |
|
1373 |
i:= Low(TAmmoType); |
|
1374 |
FollowGear^.Pos:= posCaseAmmo; |
|
1375 |
FollowGear^.AmmoType:= i; |
|
1376 |
AddCaption(GetEventString(eidNewAmmoPack), cWhiteColor, capgrpAmmoInfo); |
|
1377 |
end |
|
1378 |
end |
|
1379 |
else |
|
1380 |
begin |
|
1381 |
t:= uTot; |
|
1382 |
if (t > 0) then |
|
1383 |
begin |
|
1384 |
FollowGear:= AddGear(0, 0, gtCase, 0, _0, _0, 0); |
|
1385 |
t:= GetRandom(t); |
|
1386 |
i:= Low(TAmmoType); |
|
1387 |
FollowGear^.Pos:= posCaseUtility; |
|
1388 |
FollowGear^.AmmoType:= i; |
|
1389 |
AddCaption(GetEventString(eidNewUtilityPack), cWhiteColor, capgrpAmmoInfo); |
|
1390 |
end |
|
1391 |
end; |
|
1392 |
||
1393 |
// handles case of no ammo or utility crates - considered also placing booleans in uAmmos and altering probabilities |
|
1394 |
if (FollowGear <> nil) then |
|
1395 |
begin |
|
1396 |
FindPlace(FollowGear, true, 0, LAND_WIDTH); |
|
1397 |
||
1398 |
if (FollowGear <> nil) then |
|
1399 |
AddVoice(sndReinforce, CurrentTeam^.voicepack) |
|
1400 |
end |
|
1401 |
end; |
|
1402 |
||
1403 |
||
1404 |
function GetAmmo(Hedgehog: PHedgehog): TAmmoType; |
|
1405 |
var t, aTot: LongInt; |
|
1406 |
i: TAmmoType; |
|
1407 |
begin |
|
1408 |
Hedgehog:= Hedgehog; // avoid hint |
|
1409 |
||
1410 |
aTot:= 0; |
|
1411 |
for i:= Low(TAmmoType) to High(TAmmoType) do |
|
1412 |
if (Ammoz[i].Ammo.Propz and ammoprop_Utility) = 0 then |
|
1413 |
inc(aTot, Ammoz[i].Probability); |
|
1414 |
||
1415 |
t:= aTot; |
|
1416 |
i:= Low(TAmmoType); |
|
1417 |
if (t > 0) then |
|
1418 |
begin |
|
1419 |
t:= GetRandom(t); |
|
1420 |
while t >= 0 do |
|
1421 |
begin |
|
1422 |
inc(i); |
|
1423 |
if (Ammoz[i].Ammo.Propz and ammoprop_Utility) = 0 then |
|
1424 |
dec(t, Ammoz[i].Probability) |
|
1425 |
end |
|
1426 |
end; |
|
1427 |
GetAmmo:= i |
|
1428 |
end; |
|
1429 |
||
1430 |
function GetUtility(Hedgehog: PHedgehog): TAmmoType; |
|
1431 |
var t, uTot: LongInt; |
|
1432 |
i: TAmmoType; |
|
1433 |
begin |
|
1434 |
||
1435 |
uTot:= 0; |
|
1436 |
for i:= Low(TAmmoType) to High(TAmmoType) do |
|
1437 |
if ((Ammoz[i].Ammo.Propz and ammoprop_Utility) <> 0) |
|
1438 |
and ((Hedgehog^.Team^.HedgehogsNumber > 1) or (Ammoz[i].Ammo.AmmoType <> amSwitch)) then |
|
1439 |
inc(uTot, Ammoz[i].Probability); |
|
1440 |
||
1441 |
t:= uTot; |
|
1442 |
i:= Low(TAmmoType); |
|
1443 |
if (t > 0) then |
|
1444 |
begin |
|
1445 |
t:= GetRandom(t); |
|
1446 |
while t >= 0 do |
|
1447 |
begin |
|
1448 |
inc(i); |
|
1449 |
if ((Ammoz[i].Ammo.Propz and ammoprop_Utility) <> 0) and ((Hedgehog^.Team^.HedgehogsNumber > 1) |
|
1450 |
or (Ammoz[i].Ammo.AmmoType <> amSwitch)) then |
|
1451 |
dec(t, Ammoz[i].Probability) |
|
1452 |
end |
|
1453 |
end; |
|
1454 |
GetUtility:= i |
|
1455 |
end; |
|
1456 |
||
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1457 |
(* |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1458 |
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
|
1459 |
* Normal - infinite world, do nothing |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1460 |
* 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
|
1461 |
* 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
|
1462 |
* 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
|
1463 |
|
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1464 |
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
|
1465 |
*) |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1466 |
function WorldWrap(var Gear: PGear): boolean; |
10354 | 1467 |
//var tdx: hwFloat; |
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1468 |
begin |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1469 |
WorldWrap:= false; |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1470 |
if WorldEdge = weNone then exit(false); |
10160 | 1471 |
if (hwRound(Gear^.X) < LongInt(leftX)) or |
1472 |
(hwRound(Gear^.X) > LongInt(rightX)) then |
|
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1473 |
begin |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1474 |
if WorldEdge = weWrap then |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1475 |
begin |
10160 | 1476 |
if (hwRound(Gear^.X) < LongInt(leftX)) then |
1477 |
Gear^.X:= Gear^.X + int2hwfloat(rightX - leftX) |
|
1478 |
else Gear^.X:= Gear^.X - int2hwfloat(rightX - leftX); |
|
9557 | 1479 |
LeftImpactTimer:= 150; |
1480 |
RightImpactTimer:= 150 |
|
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1481 |
end |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1482 |
else if WorldEdge = weBounce then |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1483 |
begin |
9809 | 1484 |
if (hwRound(Gear^.X) - Gear^.Radius < LongInt(leftX)) then |
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1485 |
begin |
9557 | 1486 |
LeftImpactTimer:= 333; |
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1487 |
Gear^.dX.isNegative:= false; |
9809 | 1488 |
Gear^.X:= int2hwfloat(LongInt(leftX) + Gear^.Radius) |
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1489 |
end |
10015 | 1490 |
else |
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1491 |
begin |
9557 | 1492 |
RightImpactTimer:= 333; |
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1493 |
Gear^.dX.isNegative:= true; |
9485
3dee8a3b0406
add shotgun wrap, revert 100px offset. Problematic w/ things that rely on Land.
nemo
parents:
9479
diff
changeset
|
1494 |
Gear^.X:= int2hwfloat(rightX-Gear^.Radius) |
9557 | 1495 |
end; |
9561 | 1496 |
if (Gear^.Radius > 2) and (Gear^.dX.QWordValue > _0_001.QWordValue) then |
10508 | 1497 |
AddBounceEffectForGear(Gear); |
10354 | 1498 |
end{ |
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1499 |
else if WorldEdge = weSea then |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1500 |
begin |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1501 |
if (hwRound(Gear^.Y) > cWaterLine) and (Gear^.State and gstSubmersible <> 0) then |
9521
8054d9d775fd
merge with latest defaul, fixing compiling with fpc, parsing and rendering with pas2c, some minor problems with compiling with clang
koda
diff
changeset
|
1502 |
Gear^.State:= Gear^.State and (not gstSubmersible) |
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1503 |
else |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1504 |
begin |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1505 |
Gear^.State:= Gear^.State or gstSubmersible; |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1506 |
Gear^.X:= int2hwFloat(PlayWidth)*int2hwFloat(min(max(0,hwRound(Gear^.Y)),PlayHeight))/PlayHeight; |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1507 |
Gear^.Y:= int2hwFloat(cWaterLine+cVisibleWater+Gear^.Radius*2); |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1508 |
tdx:= Gear^.dX; |
9522 | 1509 |
Gear^.dX:= -Gear^.dY; |
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1510 |
Gear^.dY:= tdx; |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1511 |
Gear^.dY.isNegative:= true |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1512 |
end |
10354 | 1513 |
end}; |
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1514 |
(* |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1515 |
* Window in the sky (Gear moved high into the sky, Y is used to determine X) [unfortunately, not a safe thing to do. shame, I thought aerial bombardment would be kinda neat |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1516 |
This one would be really easy to freeze game unless it was flagged unfortunately. |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1517 |
|
10015 | 1518 |
else |
9473
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1519 |
begin |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1520 |
Gear^.X:= int2hwFloat(PlayWidth)*int2hwFloat(min(max(0,hwRound(Gear^.Y)),PlayHeight))/PlayHeight; |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1521 |
Gear^.Y:= -_2048-_256-_256; |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1522 |
tdx:= Gear^.dX; |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1523 |
Gear^.dX:= Gear^.dY; |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1524 |
Gear^.dY:= tdx; |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1525 |
Gear^.dY.isNegative:= false |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1526 |
end |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1527 |
*) |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1528 |
WorldWrap:= true |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1529 |
end; |
a51a69094c24
partial implementation of non-infinite world (edge wrap/warp/bounce)
nemo
parents:
9285
diff
changeset
|
1530 |
end; |
9285 | 1531 |
|
10508 | 1532 |
procedure AddBounceEffectForGear(Gear: PGear); |
1533 |
var boing: PVisualGear; |
|
1534 |
begin |
|
1535 |
boing:= AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtStraightShot, 0, false, 1); |
|
1536 |
if boing <> nil then |
|
1537 |
with boing^ do |
|
1538 |
begin |
|
1539 |
Angle:= random(360); |
|
1540 |
dx:= 0; |
|
1541 |
dy:= 0; |
|
1542 |
FrameTicks:= 200; |
|
1543 |
Scale:= hwFloat2Float(Gear^.Density * hwAbs(Gear^.dY) + hwAbs(Gear^.dX)) / 1.5; |
|
1544 |
State:= ord(sprBoing) |
|
1545 |
end; |
|
1546 |
PlaySound(sndMelonImpact, true) |
|
1547 |
end; |
|
1548 |
||
6581 | 1549 |
end. |