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