author  unc0rr 
Sun, 06 Jul 2008 19:31:12 +0000  
changeset 1055  9af540b23409 
parent 1054  80225c6af656 
child 1056  bb33a634a4b0 
permissions  rwrr 
4  1 
(* 
2 
* Hedgewars, a wormslike game 

883  3 
* Copyright (c) 20042008 Andrey Korotaev <unC0Rr@gmail.com> 
4  4 
* 
183  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 

4  8 
* 
183  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. 

4  13 
* 
183  14 
* You should have received a copy of the GNU General Public License 
15 
* along with this program; if not, write to the Free Software 

16 
* Foundation, Inc., 59 Temple Place  Suite 330, Boston, MA 021111307, USA 

4  17 
*) 
18 

19 
unit uGears; 

20 
interface 

351  21 
uses SDLh, uConsts, uFloat; 
4  22 
{$INCLUDE options.inc} 
23 
const AllInactive: boolean = false; 

868  24 
PrvInactive: boolean = false; 
4  25 

26 
type PGear = ^TGear; 

27 
TGearStepProcedure = procedure (Gear: PGear); 

28 
TGear = record 

29 
NextGear, PrevGear: PGear; 

30 
Active: Boolean; 

930  31 
Ammo : PAmmo; 
188  32 
State : Longword; 
351  33 
X : hwFloat; 
34 
Y : hwFloat; 

35 
dX: hwFloat; 

36 
dY: hwFloat; 

42  37 
Kind: TGearType; 
38 
Pos: Longword; 

4  39 
doStep: TGearStepProcedure; 
371  40 
Radius: LongInt; 
188  41 
Angle, Power : Longword; 
776
8fc7e59d9cb4
Convert the rest of rotated sprites to be rotated by OpenGL
unc0rr
parents:
775
diff
changeset

42 
DirAngle: real; 
4  43 
Timer : LongWord; 
351  44 
Elasticity: hwFloat; 
45 
Friction : hwFloat; 

783  46 
Message, MsgParam : Longword; 
4  47 
Hedgehog: pointer; 
371  48 
Health, Damage: LongInt; 
511  49 
CollisionIndex: LongInt; 
371  50 
Tag: LongInt; 
762  51 
Tex: PTexture; 
293  52 
Z: Longword; 
505
fcba7d7aea0d
Fix old bug with grenade(bomd, etc..) not colliding with attacking hedgehog
unc0rr
parents:
503
diff
changeset

53 
IntersectGear: PGear; 
595
5ee863f2f568
Triggers PoC: targets are spawned right after the previous damaged
unc0rr
parents:
593
diff
changeset

54 
TriggerId: Longword; 
4  55 
end; 
56 

371  57 
function AddGear(X, Y: LongInt; Kind: TGearType; State: Longword; dX, dY: hwFloat; Timer: LongWord): PGear; 
4  58 
procedure ProcessGears; 
59 
procedure SetAllToActive; 

60 
procedure SetAllHHToActive; 

956  61 
procedure DrawGears; 
4  62 
procedure FreeGearsList; 
10  63 
procedure AddMiscGears; 
4  64 
procedure AssignHHCoords; 
294  65 
procedure InsertGearToList(Gear: PGear); 
66 
procedure RemoveGearFromList(Gear: PGear); 

4  67 

68 
var CurAmmoGear: PGear = nil; 

68  69 
GearsList: PGear = nil; 
307  70 
KilledHHs: Longword = 0; 
70  71 

4  72 
implementation 
81  73 
uses uWorld, uMisc, uStore, uConsole, uSound, uTeams, uRandom, uCollisions, 
814
7fb4417b7bc1
Start implementing better statistics implementation (does nothing yet)
unc0rr
parents:
809
diff
changeset

74 
uLand, uIO, uLandGraphics, uAIMisc, uLocale, uAI, uAmmos, uTriggers, GL, 
1045  75 
uStats, uVisualGears; 
789  76 

77 
const MAXROPEPOINTS = 300; 

68  78 
var RopePoints: record 
4  79 
Count: Longword; 
776
8fc7e59d9cb4
Convert the rest of rotated sprites to be rotated by OpenGL
unc0rr
parents:
775
diff
changeset

80 
HookAngle: GLfloat; 
789  81 
ar: array[0..MAXROPEPOINTS] of record 
351  82 
X, Y: hwFloat; 
83 
dLen: hwFloat; 

4  84 
b: boolean; 
85 
end; 

86 
end; 

87 

88 
procedure DeleteGear(Gear: PGear); forward; 

371  89 
procedure doMakeExplosion(X, Y, Radius: LongInt; Mask: LongWord); forward; 
90 
procedure AmmoShove(Ammo: PGear; Damage, Power: LongInt); forward; 

79  91 
procedure AmmoFlameWork(Ammo: PGear); forward; 
371  92 
function CheckGearNear(Gear: PGear; Kind: TGearType; rX, rY: LongInt): PGear; forward; 
15  93 
procedure SpawnBoxOfSmth; forward; 
32
78bff13b11c0
With this patch the game doesn't crash when gaming by net
unc0rr
parents:
24
diff
changeset

94 
procedure AfterAttack; forward; 
371  95 
procedure FindPlace(Gear: PGear; withFall: boolean; Left, Right: LongInt); forward; 
302  96 
procedure HedgehogStep(Gear: PGear); forward; 
303
1659c4aad5ab
Now blow torch angle can be changed during blowing :)
unc0rr
parents:
302
diff
changeset

97 
procedure HedgehogChAngle(Gear: PGear); forward; 
506  98 
procedure ShotgunShot(Gear: PGear); forward; 
522  99 
procedure AddDamageTag(X, Y, Damage: LongWord; Gear: PGear); forward; 
4  100 

101 
{$INCLUDE GSHandlers.inc} 

102 
{$INCLUDE HHHandlers.inc} 

103 

104 
const doStepHandlers: array[TGearType] of TGearStepProcedure = ( 

351  105 
@doStepBomb, 
106 
@doStepHedgehog, 

107 
@doStepGrenade, 

108 
@doStepHealthTag, 

109 
@doStepGrave, 

110 
@doStepUFO, 

111 
@doStepShotgunShot, 

112 
@doStepPickHammer, 

113 
@doStepRope, 

114 
@doStepSmokeTrace, 

115 
@doStepExplosion, 

116 
@doStepMine, 

117 
@doStepCase, 

118 
@doStepDEagleShot, 

119 
@doStepDynamite, 

120 
@doStepTeamHealthSorter, 

121 
@doStepBomb, 

122 
@doStepCluster, 

123 
@doStepShover, 

124 
@doStepFlame, 

125 
@doStepFirePunch, 

126 
@doStepActionTimer, 

127 
@doStepActionTimer, 

128 
@doStepActionTimer, 

129 
@doStepParachute, 

130 
@doStepAirAttack, 

131 
@doStepAirBomb, 

409  132 
@doStepBlowTorch, 
520  133 
@doStepGirder, 
522  134 
@doStepTeleport, 
534  135 
@doStepHealthTag, 
590  136 
@doStepSwitcher, 
924  137 
@doStepCase, 
925  138 
@doStepMortar, 
984  139 
@doStepWhip, 
140 
@doStepKamikaze 

4  141 
); 
142 

294  143 
procedure InsertGearToList(Gear: PGear); 
803  144 
var tmp, ptmp: PGear; 
294  145 
begin 
146 
if GearsList = nil then 

147 
GearsList:= Gear 

148 
else begin 

149 
tmp:= GearsList; 

803  150 
ptmp:= GearsList; 
151 
while (tmp <> nil) and (tmp^.Z <= Gear^.Z) do 

152 
begin 

153 
ptmp:= tmp; 

154 
tmp:= tmp^.NextGear 

155 
end; 

294  156 

803  157 
if ptmp <> nil then 
158 
begin 

159 
Gear^.NextGear:= ptmp^.NextGear; 

160 
Gear^.PrevGear:= ptmp; 

161 
if ptmp^.NextGear <> nil then ptmp^.NextGear^.PrevGear:= Gear; 

162 
ptmp^.NextGear:= Gear 

163 
end 

164 
else GearsList:= Gear 

294  165 
end 
166 
end; 

167 

168 
procedure RemoveGearFromList(Gear: PGear); 

169 
begin 

351  170 
if Gear^.NextGear <> nil then Gear^.NextGear^.PrevGear:= Gear^.PrevGear; 
171 
if Gear^.PrevGear <> nil then Gear^.PrevGear^.NextGear:= Gear^.NextGear 

809  172 
else GearsList:= Gear^.NextGear 
294  173 
end; 
174 

371  175 
function AddGear(X, Y: LongInt; Kind: TGearType; State: Longword; dX, dY: hwFloat; Timer: LongWord): PGear; 
79  176 
const Counter: Longword = 0; 
351  177 
var Result: PGear; 
4  178 
begin 
79  179 
inc(Counter); 
108  180 
{$IFDEF DEBUGFILE}AddFileLog('AddGear: ('+inttostr(x)+','+inttostr(y)+'), d('+floattostr(dX)+','+floattostr(dY)+')');{$ENDIF} 
4  181 
New(Result); 
357  182 
{$IFDEF DEBUGFILE}AddFileLog('AddGear: type = ' + inttostr(ord(Kind)));{$ENDIF} 
4  183 
FillChar(Result^, sizeof(TGear), 0); 
498  184 
Result^.X:= int2hwFloat(X); 
185 
Result^.Y:= int2hwFloat(Y); 

351  186 
Result^.Kind := Kind; 
187 
Result^.State:= State; 

188 
Result^.Active:= true; 

189 
Result^.dX:= dX; 

190 
Result^.dY:= dY; 

191 
Result^.doStep:= doStepHandlers[Kind]; 

511  192 
Result^.CollisionIndex:= 1; 
351  193 
Result^.Timer:= Timer; 
505
fcba7d7aea0d
Fix old bug with grenade(bomd, etc..) not colliding with attacking hedgehog
unc0rr
parents:
503
diff
changeset

194 

4  195 
if CurrentTeam <> nil then 
505
fcba7d7aea0d
Fix old bug with grenade(bomd, etc..) not colliding with attacking hedgehog
unc0rr
parents:
503
diff
changeset

196 
begin 
602  197 
Result^.Hedgehog:= CurrentHedgehog; 
198 
Result^.IntersectGear:= CurrentHedgehog^.Gear 

505
fcba7d7aea0d
Fix old bug with grenade(bomd, etc..) not colliding with attacking hedgehog
unc0rr
parents:
503
diff
changeset

199 
end; 
802
ed5450a89b96
Start implementing 'visual gears'  gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
789
diff
changeset

200 

4  201 
case Kind of 
915  202 
gtAmmo_Bomb, 
203 
gtClusterBomb: begin 

351  204 
Result^.Radius:= 4; 
205 
Result^.Elasticity:= _0_6; 

997  206 
Result^.Friction:= _0_96; 
4  207 
end; 
208 
gtHedgehog: begin 

351  209 
Result^.Radius:= cHHRadius; 
210 
Result^.Elasticity:= _0_35; 

211 
Result^.Friction:= _0_999; 

212 
Result^.Angle:= cMaxAngle div 2; 

213 
Result^.Z:= cHHZ; 

4  214 
end; 
215 
gtAmmo_Grenade: begin 

351  216 
Result^.Radius:= 4; 
4  217 
end; 
218 
gtHealthTag: begin 

351  219 
Result^.Timer:= 1500; 
522  220 
Result^.Z:= 2001; 
4  221 
end; 
222 
gtGrave: begin 

351  223 
Result^.Radius:= 10; 
224 
Result^.Elasticity:= _0_6; 

4  225 
end; 
226 
gtUFO: begin 

351  227 
Result^.Radius:= 5; 
228 
Result^.Timer:= 500; 

229 
Result^.Elasticity:= _0_9 

4  230 
end; 
231 
gtShotgunShot: begin 

351  232 
Result^.Timer:= 900; 
233 
Result^.Radius:= 2 

4  234 
end; 
235 
gtPickHammer: begin 

351  236 
Result^.Radius:= 10; 
237 
Result^.Timer:= 4000 

4  238 
end; 
239 
gtSmokeTrace: begin 

498  240 
Result^.X:= Result^.X  _16; 
241 
Result^.Y:= Result^.Y  _16; 

351  242 
Result^.State:= 8 
4  243 
end; 
244 
gtRope: begin 

351  245 
Result^.Radius:= 3; 
498  246 
Result^.Friction:= _450; 
4  247 
RopePoints.Count:= 0; 
248 
end; 

9  249 
gtExplosion: begin 
1012  250 
Result^.X:= Result^.X; 
251 
Result^.Y:= Result^.Y; 

9  252 
end; 
10  253 
gtMine: begin 
503  254 
Result^.State:= Result^.State or gstMoving; 
915  255 
Result^.Radius:= 2; 
351  256 
Result^.Elasticity:= _0_55; 
257 
Result^.Friction:= _0_995; 

258 
Result^.Timer:= 3000; 

10  259 
end; 
14
81f125629b25
 Mine checks whether a hedgehog is near less frequently
unc0rr
parents:
10
diff
changeset

260 
gtCase: begin 
351  261 
Result^.Radius:= 16; 
601
78a68cc4d846
Special game mode allowing the only clan on map for training mode
unc0rr
parents:
595
diff
changeset

262 
Result^.Elasticity:= _0_3 
14
81f125629b25
 Mine checks whether a hedgehog is near less frequently
unc0rr
parents:
10
diff
changeset

263 
end; 
37  264 
gtDEagleShot: begin 
351  265 
Result^.Radius:= 1; 
266 
Result^.Health:= 50 

37  267 
end; 
39  268 
gtDynamite: begin 
351  269 
Result^.Radius:= 3; 
270 
Result^.Elasticity:= _0_55; 

271 
Result^.Friction:= _0_03; 

272 
Result^.Timer:= 5000; 

39  273 
end; 
910  274 
gtCluster: Result^.Radius:= 2; 
878  275 
gtShover: Result^.Radius:= 20; 
79  276 
gtFlame: begin 
351  277 
Result^.Angle:= Counter mod 64; 
278 
Result^.Radius:= 1; 

279 
Result^.Health:= 2; 

280 
Result^.dY:= (getrandom  _0_8) * _0_03; 

281 
Result^.dX:= (getrandom  _0_5) * _0_4 

79  282 
end; 
82  283 
gtFirePunch: begin 
351  284 
Result^.Radius:= 15; 
285 
Result^.Tag:= Y 

82  286 
end; 
302  287 
gtAirBomb: begin 
543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
542
diff
changeset

288 
Result^.Radius:= 5; 
302  289 
end; 
290 
gtBlowTorch: begin 

511  291 
Result^.Radius:= cHHRadius + cBlowTorchC; 
351  292 
Result^.Timer:= 7500; 
302  293 
end; 
522  294 
gtSmallDamage: begin 
295 
Result^.Timer:= 1100; 

296 
Result^.Z:= 2000; 

297 
end; 

540  298 
gtSwitcher: begin 
299 
Result^.Z:= cCurrHHZ 

300 
end; 

593  301 
gtTarget: begin 
601
78a68cc4d846
Special game mode allowing the only clan on map for training mode
unc0rr
parents:
595
diff
changeset

302 
Result^.Radius:= 16; 
78a68cc4d846
Special game mode allowing the only clan on map for training mode
unc0rr
parents:
595
diff
changeset

303 
Result^.Elasticity:= _0_3 
593  304 
end; 
924  305 
gtMortar: begin 
994  306 
Result^.Radius:= 4; 
924  307 
Result^.Elasticity:= _0_2; 
308 
Result^.Friction:= _0_08 

309 
end; 

925  310 
gtWhip: Result^.Radius:= 20; 
984  311 
gtKamikaze: begin 
312 
Result^.Health:= 2048; 

313 
Result^.Radius:= 20 

314 
end; 

4  315 
end; 
351  316 
InsertGearToList(Result); 
317 
AddGear:= Result 

4  318 
end; 
319 

320 
procedure DeleteGear(Gear: PGear); 

48  321 
var team: PTeam; 
307  322 
t: Longword; 
4  323 
begin 
503  324 
DeleteCI(Gear); 
762  325 

326 
if Gear^.Tex <> nil then 

522  327 
begin 
762  328 
FreeTexture(Gear^.Tex); 
329 
Gear^.Tex:= nil 

522  330 
end; 
762  331 

351  332 
if Gear^.Kind = gtHedgehog then 
4  333 
if CurAmmoGear <> nil then 
334 
begin 

351  335 
Gear^.Message:= gm_Destroy; 
336 
CurAmmoGear^.Message:= gm_Destroy; 

4  337 
exit 
47  338 
end else 
339 
begin 

498  340 
if not (hwRound(Gear^.Y) < cWaterLine) then 
307  341 
begin 
351  342 
t:= max(Gear^.Damage, Gear^.Health); 
867  343 
Gear^.Damage:= t; 
498  344 
AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtHealthTag, t, _0, _0, 0)^.Hedgehog:= Gear^.Hedgehog; 
867  345 
uStats.HedgehogDamaged(Gear) 
307  346 
end; 
351  347 
team:= PHedgehog(Gear^.Hedgehog)^.Team; 
602  348 
if CurrentHedgehog^.Gear = Gear then 
145  349 
FreeActionsList; // to avoid ThinkThread on drawned gear 
351  350 
PHedgehog(Gear^.Hedgehog)^.Gear:= nil; 
307  351 
inc(KilledHHs); 
48  352 
RecountTeamHealth(team); 
47  353 
end; 
357  354 
{$IFDEF DEBUGFILE}AddFileLog('DeleteGear');{$ENDIF} 
595
5ee863f2f568
Triggers PoC: targets are spawned right after the previous damaged
unc0rr
parents:
593
diff
changeset

355 
if Gear^.TriggerId <> 0 then TickTrigger(Gear^.TriggerId); 
82  356 
if CurAmmoGear = Gear then CurAmmoGear:= nil; 
4  357 
if FollowGear = Gear then FollowGear:= nil; 
294  358 
RemoveGearFromList(Gear); 
4  359 
Dispose(Gear) 
360 
end; 

361 

362 
function CheckNoDamage: boolean; // returns TRUE in case of no damaged hhs 

363 
var Gear: PGear; 

364 
begin 

351  365 
CheckNoDamage:= true; 
4  366 
Gear:= GearsList; 
367 
while Gear <> nil do 

867  368 
begin 
369 
if Gear^.Kind = gtHedgehog then 

370 
if Gear^.Damage <> 0 then 

371 
begin 

372 
CheckNoDamage:= false; 

373 
uStats.HedgehogDamaged(Gear); 

351  374 

867  375 
if Gear^.Health < Gear^.Damage then 
376 
Gear^.Health:= 0 

377 
else 

378 
dec(Gear^.Health, Gear^.Damage); 

379 

380 
AddGear(hwRound(Gear^.X), hwRound(Gear^.Y)  cHHRadius  12, 

381 
gtHealthTag, Gear^.Damage, _0, _0, 0)^.Hedgehog:= Gear^.Hedgehog; 

382 
RenderHealth(PHedgehog(Gear^.Hedgehog)^); 

383 
RecountTeamHealth(PHedgehog(Gear^.Hedgehog)^.Team); 

384 

385 
Gear^.Damage:= 0 

386 
end; 

387 
Gear:= Gear^.NextGear 

388 
end; 

4  389 
end; 
390 

1054  391 
procedure HealthMachine; 
392 
var Gear: PGear; 

393 
begin 

394 
Gear:= GearsList; 

395 

396 
while Gear <> nil do 

397 
begin 

398 
if Gear^.Kind = gtHedgehog then 

399 
Gear^.Damage:= min(cHealthDecrease, Gear^.Health  1); 

400 

401 
Gear:= Gear^.NextGear 

402 
end; 

403 
end; 

404 

1055
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

405 
function WaterMachine: boolean; 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

406 
const 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

407 
decStep: Longword = 0; 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

408 
LastTurn: LongWord = 0; 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

409 
var i: LongWord; 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

410 
begin 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

411 
if (decStep = 0) and (LastTurn < FinishedTurnsTotal) then 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

412 
begin 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

413 
LastTurn:= FinishedTurnsTotal; 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

414 
decStep:= 40 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

415 
end; 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

416 

9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

417 
if decStep <> 0 then 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

418 
begin 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

419 
dec(decStep); 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

420 
dec(cWaterLine); 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

421 
for i:= 0 to 2047 do 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

422 
Land[cWaterLine, i]:= 0; 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

423 
SetAllToActive 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

424 
end; 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

425 

9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

426 
WaterMachine:= decStep <> 0; 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

427 
end; 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

428 

522  429 
procedure AddDamageTag(X, Y, Damage: LongWord; Gear: PGear); 
430 
begin 

529  431 
if cAltDamage then 
432 
AddGear(X, Y, gtSmallDamage, Damage, _0, _0, 0)^.Hedgehog:= Gear^.Hedgehog; 

522  433 
end; 
434 

4  435 
procedure ProcessGears; 
614  436 
const delay: LongWord = 0; 
869  437 
step: (stDelay, stChDmg, stTurnReact, 
1055
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

438 
stAfterDelay, stChWin, stWater, stHealth, 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

439 
stSpawn, stNTurn) = stDelay; 
1054  440 

4  441 
var Gear, t: PGear; 
442 
begin 

868  443 
PrvInactive:= AllInactive; 
4  444 
AllInactive:= true; 
445 
t:= GearsList; 

1054  446 
while t <> nil do 
4  447 
begin 
448 
Gear:= t; 

351  449 
t:= Gear^.NextGear; 
450 
if Gear^.Active then Gear^.doStep(Gear); 

4  451 
end; 
89  452 

4  453 
if AllInactive then 
15  454 
case step of 
455 
stDelay: begin 

456 
if delay = 0 then 

457 
delay:= cInactDelay 

614  458 
else 
459 
dec(delay); 

460 

461 
if delay = 0 then 

462 
inc(step) 

15  463 
end; 
464 
stChDmg: if CheckNoDamage then inc(step) else step:= stDelay; 

814
7fb4417b7bc1
Start implementing better statistics implementation (does nothing yet)
unc0rr
parents:
809
diff
changeset

465 
stTurnReact: begin 
1054  466 
if (not bBetweenTurns) and (not isInMultiShoot) then 
855
8842c71d16bf
 Fix too long delay between shotgun and deagle shots
unc0rr
parents:
854
diff
changeset

467 
begin 
8842c71d16bf
 Fix too long delay between shotgun and deagle shots
unc0rr
parents:
854
diff
changeset

468 
uStats.TurnReaction; 
8842c71d16bf
 Fix too long delay between shotgun and deagle shots
unc0rr
parents:
854
diff
changeset

469 
inc(step) 
8842c71d16bf
 Fix too long delay between shotgun and deagle shots
unc0rr
parents:
854
diff
changeset

470 
end else 
8842c71d16bf
 Fix too long delay between shotgun and deagle shots
unc0rr
parents:
854
diff
changeset

471 
inc(step, 2); 
814
7fb4417b7bc1
Start implementing better statistics implementation (does nothing yet)
unc0rr
parents:
809
diff
changeset

472 
end; 
815  473 
stAfterDelay: begin 
474 
if delay = 0 then 

475 
delay:= cInactDelay 

476 
else 

477 
dec(delay); 

478 

479 
if delay = 0 then 

480 
inc(step) 

481 
end; 

869  482 
stChWin: if not CheckForWin then inc(step) else step:= stDelay; 
1055
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

483 
stWater: begin 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

484 
if GameTicks > 25 * 60 * 1000 then bWaterRising:= true; 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

485 

9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

486 
if not bWaterRising then inc(step); 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

487 
if delay = 0 then 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

488 
delay:= 17 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

489 
else 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

490 
dec(delay); 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

491 

9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

492 
if delay = 0 then 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

493 
if not WaterMachine then inc(step) 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

494 
end; 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

495 
stHealth: begin 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

496 
if GameTicks > 20 * 60 * 1000 then cHealthDecrease:= 5; 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

497 

9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

498 
if (cHealthDecrease = 0) 
1054  499 
or bBetweenTurns 
500 
or isInMultiShoot 

501 
or (FinishedTurnsTotal = 0) then inc(step) 

502 
else begin 

503 
bBetweenTurns:= true; 

504 
HealthMachine; 

505 
step:= stChDmg 

1055
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

506 
end 
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset

507 
end; 
15  508 
stSpawn: begin 
509 
if not isInMultiShoot then SpawnBoxOfSmth; 

510 
inc(step) 

511 
end; 

512 
stNTurn: begin 

513 
if isInMultiShoot then isInMultiShoot:= false 

307  514 
else begin 
351  515 
ParseCommand('/nextturn', true); 
1054  516 
bBetweenTurns:= false 
307  517 
end; 
15  518 
step:= Low(step) 
519 
end; 

520 
end; 

521 

4  522 
if TurnTimeLeft > 0 then 
870  523 
if CurrentHedgehog^.Gear <> nil then 
524 
if ((CurrentHedgehog^.Gear^.State and gstAttacking) = 0) 

525 
and not isInMultiShoot then 

526 
begin 

527 
if (TurnTimeLeft = 5000) 

528 
and (CurrentHedgehog^.Gear <> nil) 

529 
and ((CurrentHedgehog^.Gear^.State and gstAttacked) = 0) then PlaySound(sndHurry, false); 

530 
dec(TurnTimeLeft) 

531 
end; 

351  532 

651  533 
if (not CurrentTeam^.ExtDriven) and 
917  534 
((GameTicks and $FFFF) = $FFFF) then 
535 
begin 

536 
SendIPCTimeInc; 

537 
inc(hiTicks) // we do not recieve a message for this 

538 
end; 

656
6d6d9d7b1054
Fix network game bug caused by recent protocol changes
unc0rr
parents:
651
diff
changeset

539 

515  540 
inc(GameTicks) 
4  541 
end; 
542 

543 
procedure SetAllToActive; 

544 
var t: PGear; 

545 
begin 

546 
AllInactive:= false; 

547 
t:= GearsList; 

351  548 
while t <> nil do 
4  549 
begin 
351  550 
t^.Active:= true; 
551 
t:= t^.NextGear 

4  552 
end 
553 
end; 

554 

555 
procedure SetAllHHToActive; 

556 
var t: PGear; 

557 
begin 

558 
AllInactive:= false; 

559 
t:= GearsList; 

351  560 
while t <> nil do 
4  561 
begin 
351  562 
if t^.Kind = gtHedgehog then t^.Active:= true; 
563 
t:= t^.NextGear 

4  564 
end 
565 
end; 

566 

841
0700e3d3474d
Get rid if deprecated Surface parameter of Draw* calls
unc0rr
parents:
840
diff
changeset

567 
procedure DrawHH(Gear: PGear); 
371  568 
var t: LongInt; 
822  569 
amt: TAmmoType; 
862  570 
hx, hy, m: LongInt; 
571 
aAngle, dAngle: real; 

824  572 
defaultPos: boolean; 
292  573 
begin 
868  574 
if (Gear^.State and gstHHDeath) <> 0 then 
575 
begin 

576 
DrawSprite(sprHHDeath, hwRound(Gear^.X)  16 + WorldDx, hwRound(Gear^.Y)  26 + WorldDy, Gear^.Pos); 

577 
exit 

578 
end; 

1002  579 

824  580 
defaultPos:= true; 
847  581 

1002  582 
if (Gear^.State and gstDrowning) <> 0 then 
583 
begin 

584 
DrawHedgehog(hwRound(Gear^.X) + 1 + WorldDx, hwRound(Gear^.Y)  3 + WorldDy, 

585 
hwSign(Gear^.dX), 

586 
1, 

587 
7, 

588 
0); 

589 
defaultPos:= false 

590 
end else 

591 

1011  592 
if (Gear^.State and gstWinner) <> 0 then 
593 
begin 

594 
DrawHedgehog(hwRound(Gear^.X) + 1 + WorldDx, hwRound(Gear^.Y)  3 + WorldDy, 

595 
hwSign(Gear^.dX), 

596 
2, 

597 
0, 

598 
0); 

599 
defaultPos:= false 

600 
end else 

601 

821
e6c0408b54ed
Use 'regular standing' and 'rope swing' hedgehog sprites
unc0rr
parents:
815
diff
changeset

602 
if (Gear^.State and gstHHDriven) <> 0 then 
966  603 
begin 
1002  604 
hx:= hwRound(Gear^.X) + 1 + 8 * hwSign(Gear^.dX) + WorldDx; 
605 
hy:= hwRound(Gear^.Y)  2 + WorldDy; 

606 
aangle:= Gear^.Angle * 180 / cMaxAngle  90; 

874  607 

1002  608 
if CurAmmoGear <> nil then 
609 
begin 

610 
case CurAmmoGear^.Kind of 

611 
gtShotgunShot: if (CurAmmoGear^.State and gstAnimation <> 0) then 

612 
DrawRotated(sprShotgun, hx, hy, hwSign(Gear^.dX), aangle) 

613 
else 

614 
DrawRotated(sprHandShotgun, hx, hy, hwSign(Gear^.dX), aangle); 

615 
gtDEagleShot: DrawRotated(sprDEagle, hx, hy, hwSign(Gear^.dX), aangle); 

616 
gtRope: begin 

617 
if Gear^.X < CurAmmoGear^.X then 

618 
begin 

619 
dAngle:= 0; 

620 
m:= 1 

621 
end else 

622 
begin 

623 
dAngle:= 180; 

624 
m:= 1 

966  625 
end; 
1002  626 
DrawHedgehog(hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, 
627 
m, 

628 
1, 

629 
0, 

630 
DxDy2Angle(CurAmmoGear^.dY, CurAmmoGear^.dX) + dAngle); 

631 
defaultPos:= false 

632 
end; 

633 
gtBlowTorch: begin 

634 
DrawRotated(sprBlowTorch, hx, hy, hwSign(Gear^.dX), aangle); 

635 
DrawHedgehog(hwRound(Gear^.X) + 1 + WorldDx, hwRound(Gear^.Y)  3 + WorldDy, 

636 
hwSign(Gear^.dX), 

637 
1, 

638 
3, 

639 
0); 

640 
defaultPos:= false 

641 
end; 

642 
gtShover: DrawRotated(sprHandBaseball, hx, hy, hwSign(Gear^.dX), aangle + 180); 

643 
gtFirePunch: begin 

644 
DrawHedgehog(hwRound(Gear^.X) + 1 + WorldDx, hwRound(Gear^.Y)  3 + WorldDy, 

645 
hwSign(Gear^.dX), 

646 
1, 

647 
4, 

648 
0); 

649 
defaultPos:= false 

650 
end; 

651 
gtPickHammer, 

652 
gtTeleport: defaultPos:= false; 

1010  653 
gtWhip: begin 
654 
DrawRotatedF(sprWhip, 

655 
hwRound(Gear^.X) + 1 + WorldDx, 

656 
hwRound(Gear^.Y)  3 + WorldDy, 

657 
1, 

658 
hwSign(Gear^.dX), 

659 
0); 

660 
defaultPos:= false 

661 
end; 

1002  662 
gtKamikaze: begin 
663 
if CurAmmoGear^.Pos = 0 then 

664 
DrawHedgehog(hwRound(Gear^.X) + 1 + WorldDx, hwRound(Gear^.Y)  3 + WorldDy, 

665 
hwSign(Gear^.dX), 

666 
1, 

667 
6, 

668 
0) 

669 
else 

670 
DrawRotatedF(sprKamikaze, 

671 
hwRound(Gear^.X) + WorldDx, 

672 
hwRound(Gear^.Y) + WorldDy, 

673 
CurAmmoGear^.Pos  1, 

674 
1, 

675 
DxDy2Angle(Gear^.dY, Gear^.dX)); 

676 

677 
defaultPos:= false 

678 
end; 

679 
end; 

680 

681 
case CurAmmoGear^.Kind of 

682 
gtShotgunShot, 

683 
gtDEagleShot, 

684 
gtShover: begin 

685 
DrawHedgehog(hwRound(Gear^.X) + 1 + WorldDx, hwRound(Gear^.Y)  3 + WorldDy, 

686 
hwSign(Gear^.dX), 

687 
0, 

688 
4, 

689 
0); 

690 
defaultPos:= false 

691 
end 

692 
end 

693 
end else 

876  694 

1002  695 
if ((Gear^.State and gstHHJumping) <> 0) then 
696 
begin 

697 
if ((Gear^.State and gstHHHJump) <> 0) then 

698 
DrawHedgehog(hwRound(Gear^.X) + 1 + WorldDx, hwRound(Gear^.Y)  3 + WorldDy, 

699 
 hwSign(Gear^.dX), 

700 
1, 

701 
1, 

702 
0) 

703 
else 

704 
DrawHedgehog(hwRound(Gear^.X) + 1 + WorldDx, hwRound(Gear^.Y)  3 + WorldDy, 

705 
hwSign(Gear^.dX), 

706 
1, 

707 
1, 

708 
0); 

709 
defaultPos:= false 

710 
end else 

874  711 

1002  712 
if (Gear^.Message and (gm_Left or gm_Right) <> 0) then 
824  713 
begin 
1002  714 
DrawHedgehog(hwRound(Gear^.X) + 1 + WorldDx, hwRound(Gear^.Y)  3 + WorldDy, 
715 
hwSign(Gear^.dX), 

716 
0, 

717 
PHedgehog(Gear^.Hedgehog)^.visStepPos div 2, 

718 
0); 

824  719 
defaultPos:= false 
1002  720 
end 
721 
else 

722 

1033  723 
if ((Gear^.State and gstAnimation) <> 0) then 
724 
begin 

1034  725 
DrawRotatedF(Wavez[TWave(Gear^.Tag)].Sprite, 
1033  726 
hwRound(Gear^.X) + 1 + WorldDx, 
727 
hwRound(Gear^.Y)  3 + WorldDy, 

728 
Gear^.Pos, 

729 
hwSign(Gear^.dX), 

730 
0.0); 

731 
defaultPos:= false 

732 
end 

733 
else 

1002  734 
if ((Gear^.State and gstAttacked) = 0) then 
735 
begin 

736 
amt:= CurrentHedgehog^.Ammo^[CurrentHedgehog^.CurSlot, CurrentHedgehog^.CurAmmo].AmmoType; 

737 
case amt of 

738 
amBazooka, 

739 
amMortar: DrawRotated(sprHandBazooka, hx, hy, hwSign(Gear^.dX), aangle); 

740 
amRope: DrawRotated(sprHandRope, hx, hy, hwSign(Gear^.dX), aangle); 

741 
amShotgun: DrawRotated(sprHandShotgun, hx, hy, hwSign(Gear^.dX), aangle); 

742 
amDEagle: DrawRotated(sprHandDEagle, hx, hy, hwSign(Gear^.dX), aangle); 

743 
amBlowTorch: DrawRotated(sprHandBlowTorch, hx, hy, hwSign(Gear^.dX), aangle); 

744 
end; 

745 

746 
case amt of 

747 
amAirAttack, 

748 
amMineStrike: DrawRotated(sprHandAirAttack, hwRound(Gear^.X) + 1 + WorldDx, hwRound(Gear^.Y) + WorldDy, hwSign(Gear^.dX), 0); 

749 
amPickHammer: DrawHedgehog(hwRound(Gear^.X) + 1 + WorldDx, hwRound(Gear^.Y)  3 + WorldDy, 

750 
hwSign(Gear^.dX), 

751 
1, 

752 
2, 

753 
0); 

754 
amBlowTorch: DrawHedgehog(hwRound(Gear^.X) + 1 + WorldDx, hwRound(Gear^.Y)  3 + WorldDy, 

755 
hwSign(Gear^.dX), 

756 
1, 

757 
3, 

758 
0); 

759 
amTeleport: DrawRotatedF(sprTeleport, hwRound(Gear^.X) + 1 + WorldDx, hwRound(Gear^.Y)  3 + WorldDy, 0, hwSign(Gear^.dX), 0); 

760 
amKamikaze: DrawHedgehog(hwRound(Gear^.X) + 1 + WorldDx, hwRound(Gear^.Y)  3 + WorldDy, 

761 
hwSign(Gear^.dX), 

762 
1, 

763 
5, 

764 
0); 

1010  765 
amWhip: begin 
766 
DrawRotatedF(sprWhip, 

767 
hwRound(Gear^.X) + 1 + WorldDx, 

768 
hwRound(Gear^.Y)  3 + WorldDy, 

769 
0, 

770 
hwSign(Gear^.dX), 

771 
0); 

772 
defaultPos:= false 

773 
end; 

1002  774 
else 
822  775 
DrawHedgehog(hwRound(Gear^.X) + 1 + WorldDx, hwRound(Gear^.Y)  3 + WorldDy, 
776 
hwSign(Gear^.dX), 

777 
0, 

1002  778 
4, 
822  779 
0); 
1002  780 
end; 
966  781 

1002  782 
case amt of 
783 
amBaseballBat: DrawRotated(sprHandBaseball, 

784 
hwRound(Gear^.X) + 1  4 * hwSign(Gear^.dX) + WorldDx, 

785 
hwRound(Gear^.Y) + 6 + WorldDy, hwSign(Gear^.dX), aangle); 

786 
end; 

966  787 

1002  788 
defaultPos:= false 
789 
end 

790 
end else // not gstHHDriven 

1012  791 
begin 
1014
3c7d4e7ccdff
 Fix firepunch sprite direction when use in high jump
unc0rr
parents:
1013
diff
changeset

792 
if (Gear^.Damage > 0) 
3c7d4e7ccdff
 Fix firepunch sprite direction when use in high jump
unc0rr
parents:
1013
diff
changeset

793 
and (hwSqr(Gear^.dX) + hwSqr(Gear^.dY) > _0_003) then 
3c7d4e7ccdff
 Fix firepunch sprite direction when use in high jump
unc0rr
parents:
1013
diff
changeset

794 
begin 
1012  795 
DrawHedgehog(hwRound(Gear^.X) + 1 + WorldDx, hwRound(Gear^.Y)  3 + WorldDy, 
796 
hwSign(Gear^.dX), 

1014
3c7d4e7ccdff
 Fix firepunch sprite direction when use in high jump
unc0rr
parents:
1013
diff
changeset

797 
2, 
1012  798 
1, 
1014
3c7d4e7ccdff
 Fix firepunch sprite direction when use in high jump
unc0rr
parents:
1013
diff
changeset

799 
Gear^.DirAngle); 
1012  800 
defaultPos:= false 
1020  801 
end else 
1014
3c7d4e7ccdff
 Fix firepunch sprite direction when use in high jump
unc0rr
parents:
1013
diff
changeset

802 

3c7d4e7ccdff
 Fix firepunch sprite direction when use in high jump
unc0rr
parents:
1013
diff
changeset

803 
if ((Gear^.State and gstHHJumping) <> 0) then 
3c7d4e7ccdff
 Fix firepunch sprite direction when use in high jump
unc0rr
parents:
1013
diff
changeset

804 
begin 
3c7d4e7ccdff
 Fix firepunch sprite direction when use in high jump
unc0rr
parents:
1013
diff
changeset

805 
if ((Gear^.State and gstHHHJump) <> 0) then 
3c7d4e7ccdff
 Fix firepunch sprite direction when use in high jump
unc0rr
parents:
1013
diff
changeset

806 
DrawHedgehog(hwRound(Gear^.X) + 1 + WorldDx, hwRound(Gear^.Y)  3 + WorldDy, 
3c7d4e7ccdff
 Fix firepunch sprite direction when use in high jump
unc0rr
parents:
1013
diff
changeset

807 
 hwSign(Gear^.dX), 
3c7d4e7ccdff
 Fix firepunch sprite direction when use in high jump
unc0rr
parents:
1013
diff
changeset

808 
1, 
3c7d4e7ccdff
 Fix firepunch sprite direction when use in high jump
unc0rr
parents:
1013
diff
changeset

809 
1, 
3c7d4e7ccdff
 Fix firepunch sprite direction when use in high jump
unc0rr
parents:
1013
diff
changeset

810 
0) 
3c7d4e7ccdff
 Fix firepunch sprite direction when use in high jump
unc0rr
parents:
1013
diff
changeset

811 
else 
3c7d4e7ccdff
 Fix firepunch sprite direction when use in high jump
unc0rr
parents:
1013
diff
changeset

812 
DrawHedgehog(hwRound(Gear^.X) + 1 + WorldDx, hwRound(Gear^.Y)  3 + WorldDy, 
3c7d4e7ccdff
 Fix firepunch sprite direction when use in high jump
unc0rr
parents:
1013
diff
changeset

813 
hwSign(Gear^.dX), 
3c7d4e7ccdff
 Fix firepunch sprite direction when use in high jump
unc0rr
parents:
1013
diff
changeset

814 
1, 
3c7d4e7ccdff
 Fix firepunch sprite direction when use in high jump
unc0rr
parents:
1013
diff
changeset

815 
1, 
3c7d4e7ccdff
 Fix firepunch sprite direction when use in high jump
unc0rr
parents:
1013
diff
changeset

816 
0); 
3c7d4e7ccdff
 Fix firepunch sprite direction when use in high jump
unc0rr
parents:
1013
diff
changeset

817 
defaultPos:= false 
3c7d4e7ccdff
 Fix firepunch sprite direction when use in high jump
unc0rr
parents:
1013
diff
changeset

818 
end; 
1012  819 
end; 
834  820 

824  821 

845  822 
if defaultPos then 
970  823 
begin 
954  824 
DrawRotatedF(sprHHIdle, 
825 
hwRound(Gear^.X) + 1 + WorldDx, 

826 
hwRound(Gear^.Y)  3 + WorldDy, 

957  827 
(RealTicks div 128 + Gear^.Pos) mod 19, 
822  828 
hwSign(Gear^.dX), 
829 
0); 

970  830 
DrawRotatedF(sprHat, 
831 
hwRound(Gear^.X) + 1 + WorldDx, 

832 
hwRound(Gear^.Y)  8 + WorldDy, 

833 
(RealTicks div 128 + Gear^.Pos) mod 19, 

834 
hwSign(Gear^.dX), 

835 
0); 

836 
end; 

292  837 

351  838 
with PHedgehog(Gear^.Hedgehog)^ do 
994  839 
begin 
1011  840 
if ((Gear^.State and not gstWinner) = 0) 
994  841 
or (bShowFinger and ((Gear^.State and gstHHDriven) <> 0)) then 
958  842 
begin 
976  843 
t:= hwRound(Gear^.Y)  cHHRadius  12 + WorldDy; 
958  844 
if (cTagsMask and 1) <> 0 then 
845 
begin 

846 
dec(t, HealthTagTex^.h + 2); 

847 
DrawCentered(hwRound(Gear^.X) + WorldDx, t, HealthTagTex) 

848 
end; 

849 
if (cTagsMask and 2) <> 0 then 

850 
begin 

851 
dec(t, NameTagTex^.h + 2); 

852 
DrawCentered(hwRound(Gear^.X) + WorldDx, t, NameTagTex) 

853 
end; 

854 
if (cTagsMask and 4) <> 0 then 

855 
begin 

856 
dec(t, Team^.NameTagTex^.h + 2); 

857 
DrawCentered(hwRound(Gear^.X) + WorldDx, t, Team^.NameTagTex) 

858 
end 

994  859 
end; 
860 
if (Gear^.State and gstHHDriven) <> 0 then // Current hedgehog 

958  861 
begin 
862 
if bShowFinger and ((Gear^.State and gstHHDriven) <> 0) then 

863 
DrawSprite(sprFinger, hwRound(Gear^.X)  16 + WorldDx, hwRound(Gear^.Y)  64 + WorldDy, 

864 
GameTicks div 32 mod 16); 

821
e6c0408b54ed
Use 'regular standing' and 'rope swing' hedgehog sprites
unc0rr
parents:
815
diff
changeset

865 

958  866 
if (Gear^.State and gstDrowning) = 0 then 
867 
if (Gear^.State and gstHHThinking) <> 0 then 

868 
DrawSprite(sprQuestion, hwRound(Gear^.X)  10 + WorldDx, hwRound(Gear^.Y)  cHHRadius  34 + WorldDy, 0) 

869 
else 

1033  870 
if ShowCrosshair and ((Gear^.State and (gstAttacked or gstAnimation)) = 0) then 
958  871 
begin 
872 
if ((Gear^.State and gstHHHJump) <> 0) then m:= 1 else m:= 1; 

873 
DrawRotatedTex(Team^.CrosshairTex, 

874 
12, 12, 

875 
Round(hwRound(Gear^.X) + hwSign(Gear^.dX) * m * Sin(Gear^.Angle*pi/cMaxAngle) * 60) + WorldDx, 

876 
Round(hwRound(Gear^.Y)  Cos(Gear^.Angle*pi/cMaxAngle) * 60) + WorldDy, 0, 

877 
hwSign(Gear^.dX) * (Gear^.Angle * 180.0) / cMaxAngle) 

878 
end 

994  879 
end 
880 
end 

292  881 
end; 
882 

956  883 
procedure DrawGears; 
853  884 
var Gear, HHGear: PGear; 
4  885 
i: Longword; 
371  886 
roplen: LongInt; 
4  887 

371  888 
procedure DrawRopeLine(X1, Y1, X2, Y2: LongInt); 
889 
var eX, eY, dX, dY: LongInt; 

890 
i, sX, sY, x, y, d: LongInt; 

366  891 
b: boolean; 
4  892 
begin 
37  893 
if (X1 = X2) and (Y1 = Y2) then 
894 
begin 

351  895 
OutError('WARNING: zero length rope line!', false); 
37  896 
exit 
897 
end; 

366  898 
eX:= 0; 
899 
eY:= 0; 

900 
dX:= X2  X1; 

901 
dY:= Y2  Y1; 

902 

903 
if (dX > 0) then sX:= 1 

904 
else 

905 
if (dX < 0) then 

906 
begin 

907 
sX:= 1; 

908 
dX:= dX 

909 
end else sX:= dX; 

910 

911 
if (dY > 0) then sY:= 1 

912 
else 

913 
if (dY < 0) then 

4  914 
begin 
366  915 
sY:= 1; 
916 
dY:= dY 

917 
end else sY:= dY; 

918 

919 
if (dX > dY) then d:= dX 

920 
else d:= dY; 

921 

922 
x:= X1; 

923 
y:= Y1; 

924 

925 
for i:= 0 to d do 

926 
begin 

927 
inc(eX, dX); 

928 
inc(eY, dY); 

929 
b:= false; 

930 
if (eX > d) then 

35  931 
begin 
366  932 
dec(eX, d); 
933 
inc(x, sX); 

934 
b:= true 

35  935 
end; 
366  936 
if (eY > d) then 
35  937 
begin 
366  938 
dec(eY, d); 
939 
inc(y, sY); 

940 
b:= true 

35  941 
end; 
366  942 
if b then 
943 
begin 

944 
inc(roplen); 

841
0700e3d3474d
Get rid if deprecated Surface parameter of Draw* calls
unc0rr
parents:
840
diff
changeset

945 
if (roplen mod 4) = 0 then DrawSprite(sprRopeNode, x  2, y  2, 0) 
366  946 
end 
4  947 
end 
366  948 
end; 
4  949 

950 
begin 

951 
Gear:= GearsList; 

952 
while Gear<>nil do 

953 
begin 

351  954 
case Gear^.Kind of 
822  955 
gtAmmo_Bomb: DrawRotated(sprBomb, hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, 0, Gear^.DirAngle); 
841
0700e3d3474d
Get rid if deprecated Surface parameter of Draw* calls
unc0rr
parents:
840
diff
changeset

956 
gtHedgehog: DrawHH(Gear); 
822  957 
gtAmmo_Grenade: DrawRotated(sprGrenade, hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, 0, DxDy2Angle(Gear^.dY, Gear^.dX)); 
522  958 
gtHealthTag, 
762  959 
gtSmallDamage: if Gear^.Tex <> nil then DrawCentered(hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, Gear^.Tex); 
841
0700e3d3474d
Get rid if deprecated Surface parameter of Draw* calls
unc0rr
parents:
840
diff
changeset

960 
gtGrave: DrawSurfSprite(hwRound(Gear^.X) + WorldDx  16, hwRound(Gear^.Y) + WorldDy  16, 32, (GameTicks shr 7) and 7, PHedgehog(Gear^.Hedgehog)^.Team^.GraveTex); 
0700e3d3474d
Get rid if deprecated Surface parameter of Draw* calls
unc0rr
parents:
840
diff
changeset

961 
gtUFO: DrawSprite(sprUFO, hwRound(Gear^.X)  16 + WorldDx, hwRound(Gear^.Y)  16 + WorldDy, (GameTicks shr 7) mod 4); 
848  962 
gtPickHammer: DrawSprite(sprPHammer, hwRound(Gear^.X)  16 + WorldDx, hwRound(Gear^.Y)  50 + LongInt(((GameTicks shr 5) and 1) * 2) + WorldDy, 0); 
4  963 
gtRope: begin 
35  964 
roplen:= 0; 
4  965 
if RopePoints.Count > 0 then 
966 
begin 

967 
i:= 0; 

968 
while i < Pred(RopePoints.Count) do 

969 
begin 

351  970 
DrawRopeLine(hwRound(RopePoints.ar[i].X) + WorldDx, hwRound(RopePoints.ar[i].Y) + WorldDy, 
971 
hwRound(RopePoints.ar[Succ(i)].X) + WorldDx, hwRound(RopePoints.ar[Succ(i)].Y) + WorldDy); 

4  972 
inc(i) 
973 
end; 

351  974 
DrawRopeLine(hwRound(RopePoints.ar[i].X) + WorldDx, hwRound(RopePoints.ar[i].Y) + WorldDy, 
975 
hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy); 

976 
DrawRopeLine(hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, 

977 
hwRound(PHedgehog(Gear^.Hedgehog)^.Gear^.X) + WorldDx, hwRound(PHedgehog(Gear^.Hedgehog)^.Gear^.Y) + WorldDy); 

822  978 
DrawRotated(sprRopeHook, hwRound(RopePoints.ar[0].X) + WorldDx, hwRound(RopePoints.ar[0].Y) + WorldDy, 1, RopePoints.HookAngle) 
4  979 
end else 
35  980 
begin 
351  981 
DrawRopeLine(hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, 
982 
hwRound(PHedgehog(Gear^.Hedgehog)^.Gear^.X) + WorldDx, hwRound(PHedgehog(Gear^.Hedgehog)^.Gear^.Y) + WorldDy); 

822  983 
DrawRotated(sprRopeHook, hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, 0, DxDy2Angle(Gear^.dY, Gear^.dX)); 
35  984 
end; 
4  985 
end; 
841
0700e3d3474d
Get rid if deprecated Surface parameter of Draw* calls
unc0rr
parents:
840
diff
changeset

986 
gtSmokeTrace: if Gear^.State < 8 then DrawSprite(sprSmokeTrace, hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, Gear^.State); 
1012  987 
gtExplosion: DrawSprite(sprExplosion50, hwRound(Gear^.X)  32 + WorldDx, hwRound(Gear^.Y)  32 + WorldDy, Gear^.State); 
351  988 
gtMine: if ((Gear^.State and gstAttacking) = 0)or((Gear^.Timer and $3FF) < 420) 
822  989 
then DrawRotated(sprMineOff, hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, 0, Gear^.DirAngle) 
990 
else DrawRotated(sprMineOn, hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, 0, Gear^.DirAngle); 

351  991 
gtCase: case Gear^.Pos of 
841
0700e3d3474d
Get rid if deprecated Surface parameter of Draw* calls
unc0rr
parents:
840
diff
changeset

992 
posCaseAmmo : DrawSprite(sprCase, hwRound(Gear^.X)  16 + WorldDx, hwRound(Gear^.Y)  16 + WorldDy, 0); 
1009  993 
posCaseHealth: begin 
994 
i:= (GameTicks shr 6) mod 64; 

995 
if i > 12 then i:= 0; 

996 
DrawSprite(sprFAid, hwRound(Gear^.X)  24 + WorldDx, hwRound(Gear^.Y)  24 + WorldDy, i); 

997 
end; 

42  998 
end; 
841
0700e3d3474d
Get rid if deprecated Surface parameter of Draw* calls
unc0rr
parents:
840
diff
changeset

999 
gtDynamite: DrawSprite2(sprDynamite, hwRound(Gear^.X)  16 + WorldDx, hwRound(Gear^.Y)  25 + WorldDy, Gear^.Tag and 1, Gear^.Tag shr 1); 
822  1000 
gtClusterBomb: DrawRotated(sprClusterBomb, hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, 0, Gear^.DirAngle); 
841
0700e3d3474d
Get rid if deprecated Surface parameter of Draw* calls
unc0rr
parents:
840
diff
changeset

1001 
gtCluster: DrawSprite(sprClusterParticle, hwRound(Gear^.X)  8 + WorldDx, hwRound(Gear^.Y)  8 + WorldDy, 0); 
0700e3d3474d
Get rid if deprecated Surface parameter of Draw* calls
unc0rr
parents:
840
diff
changeset

1002 
gtFlame: DrawSprite(sprFlame, hwRound(Gear^.X)  8 + WorldDx, hwRound(Gear^.Y)  8 + WorldDy,(GameTicks div 128 + Gear^.Angle) mod 8); 
0700e3d3474d
Get rid if deprecated Surface parameter of Draw* calls
unc0rr
parents:
840
diff
changeset

1003 
gtParachute: DrawSprite(sprParachute, hwRound(Gear^.X)  24 + WorldDx, hwRound(Gear^.Y)  48 + WorldDy, 0); 
0700e3d3474d
Get rid if deprecated Surface parameter of Draw* calls
unc0rr
parents:
840
diff
changeset

1004 
gtAirAttack: if Gear^.Tag > 0 then DrawSprite(sprAirplane, hwRound(Gear^.X)  60 + WorldDx, hwRound(Gear^.Y)  25 + WorldDy, 0) 
0700e3d3474d
Get rid if deprecated Surface parameter of Draw* calls
unc0rr
parents:
840
diff
changeset

1005 
else DrawSprite(sprAirplane, hwRound(Gear^.X)  60 + WorldDx, hwRound(Gear^.Y)  25 + WorldDy, 1); 
822  1006 
gtAirBomb: DrawRotated(sprAirBomb, hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, 0, DxDy2Angle(Gear^.dY, Gear^.dX)); 
853  1007 
gtTeleport: begin 
1008 
HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear; 

1009 
DrawRotatedF(sprTeleport, hwRound(Gear^.X) + 1 + WorldDx, hwRound(Gear^.Y)  3 + WorldDy, Gear^.Pos, hwSign(HHGear^.dX), 0); 

1010 
DrawRotatedF(sprTeleport, hwRound(HHGear^.X) + 1 + WorldDx, hwRound(HHGear^.Y)  3 + WorldDy, 11  Gear^.Pos, hwSign(HHGear^.dX), 0); 

1011 
end; 

841
0700e3d3474d
Get rid if deprecated Surface parameter of Draw* calls
unc0rr
parents:
840
diff
changeset

1012 
gtSwitcher: DrawSprite(sprSwitch, hwRound(Gear^.X)  16 + WorldDx, hwRound(Gear^.Y)  56 + WorldDy, (GameTicks shr 6) mod 12); 
0700e3d3474d
Get rid if deprecated Surface parameter of Draw* calls
unc0rr
parents:
840
diff
changeset

1013 
gtTarget: DrawSprite(sprTarget, hwRound(Gear^.X)  16 + WorldDx, hwRound(Gear^.Y)  16 + WorldDy, 0); 
959  1014 
gtMortar: DrawRotated(sprMortar, hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, 0, DxDy2Angle(Gear^.dY, Gear^.dX)); 
4  1015 
end; 
351  1016 
Gear:= Gear^.NextGear 
4  1017 
end; 
1018 
end; 

1019 

1020 
procedure FreeGearsList; 

1021 
var t, tt: PGear; 

1022 
begin 

1023 
tt:= GearsList; 

1024 
GearsList:= nil; 

1025 
while tt<>nil do 

1026 
begin 

1027 
t:= tt; 

351  1028 
tt:= tt^.NextGear; 
4  1029 
Dispose(t) 
1030 
end; 

1031 
end; 

1032 

10  1033 
procedure AddMiscGears; 
371  1034 
var i: LongInt; 
4  1035 
begin 
498  1036 
AddGear(0, 0, gtATStartGame, 0, _0, _0, 2000); 
22  1037 
if (GameFlags and gfForts) = 0 then 
622  1038 
for i:= 0 to Pred(cLandAdditions) do 
498  1039 
FindPlace(AddGear(0, 0, gtMine, 0, _0, _0, 0), false, 0, 2048); 
4  1040 
end; 
1041 

371  1042 
procedure doMakeExplosion(X, Y, Radius: LongInt; Mask: LongWord); 
4  1043 
var Gear: PGear; 
506  1044 
dmg, dmgRadius: LongInt; 
4  1045 
begin 
1046 
TargetPoint.X:= NoPointX; 

1047 
{$IFDEF DEBUGFILE}if Radius > 3 then AddFileLog('Explosion: at (' + inttostr(x) + ',' + inttostr(y) + ')');{$ENDIF} 

1049  1048 
if (Radius > 10) then AddGear(X, Y, gtExplosion, 0, _0, _0, 0); 
355  1049 
if (Mask and EXPLAutoSound) <> 0 then PlaySound(sndExplosion, false); 
506  1050 
if (Mask and EXPLAllDamageInRadius)=0 then dmgRadius:= Radius shl 1 
1051 
else dmgRadius:= Radius; 

4  1052 
Gear:= GearsList; 
1053 
while Gear <> nil do 

1054 
begin 

506  1055 
dmg:= dmgRadius  hwRound(Distance(Gear^.X  int2hwFloat(X), Gear^.Y  int2hwFloat(Y))); 
538  1056 
if (dmg > 1) and 
522  1057 
((Gear^.State and gstNoDamage) = 0) then 
4  1058 
begin 
355  1059 
dmg:= dmg div 2; 
351  1060 
case Gear^.Kind of 
10  1061 
gtHedgehog, 
14
81f125629b25
 Mine checks whether a hedgehog is near less frequently
unc0rr
parents:
10
diff
changeset

1062 
gtMine, 
79  1063 
gtCase, 
593  1064 
gtTarget, 
79  1065 
gtFlame: begin 
355  1066 
{$IFDEF DEBUGFILE}AddFileLog('Damage: ' + inttostr(dmg));{$ENDIF} 
522  1067 
if (Mask and EXPLNoDamage) = 0 then 
1068 
begin 

1069 
inc(Gear^.Damage, dmg); 

1070 
if Gear^.Kind = gtHedgehog then 

1071 
AddDamageTag(hwRound(Gear^.X), hwRound(Gear^.Y), dmg, Gear) 

1072 
end; 

351  1073 
if ((Mask and EXPLDoNotTouchHH) = 0) or (Gear^.Kind <> gtHedgehog) then 
42  1074 
begin 
506  1075 
DeleteCI(Gear); 
498  1076 
Gear^.dX:= Gear^.dX + SignAs(_0_005 * dmg + cHHKick, Gear^.X  int2hwFloat(X)); 
1077 
Gear^.dY:= Gear^.dY + SignAs(_0_005 * dmg + cHHKick, Gear^.Y  int2hwFloat(Y)); 

503  1078 
Gear^.State:= Gear^.State or gstMoving; 
351  1079 
Gear^.Active:= true; 
42  1080 
FollowGear:= Gear 
1081 
end; 

4  1082 
end; 
51  1083 
gtGrave: begin 
351  1084 
Gear^.dY:=  _0_004 * dmg; 
1085 
Gear^.Active:= true; 

51  1086 
end; 
4  1087 
end; 
1088 
end; 

351  1089 
Gear:= Gear^.NextGear 
80  1090 
end; 
621  1091 
if (Mask and EXPLDontDraw) = 0 then 
1092 
if (GameFlags and gfSolidLand) = 0 then DrawExplosion(X, Y, Radius); 

498  1093 
uAIMisc.AwareOfExplosion(0, 0, 0) 
4  1094 
end; 
1095 

506  1096 
procedure ShotgunShot(Gear: PGear); 
1097 
var t: PGear; 

955  1098 
dmg: LongInt; 
506  1099 
begin 
509  1100 
Gear^.Radius:= cShotgunRadius; 
506  1101 
t:= GearsList; 
1102 
while t <> nil do 

1103 
begin 

1104 
dmg:= min(Gear^.Radius + t^.Radius  hwRound(Distance(Gear^.X  t^.X, Gear^.Y  t^.Y)), 25); 

538  1105 
if dmg > 0 then 
506  1106 
case t^.Kind of 
1107 
gtHedgehog, 

1108 
gtMine, 

593  1109 
gtCase, 
1110 
gtTarget: begin 

506  1111 
inc(t^.Damage, dmg); 
867  1112 

522  1113 
if t^.Kind = gtHedgehog then 
531  1114 
AddDamageTag(hwRound(Gear^.X), hwRound(Gear^.Y), dmg, t); 
867  1115 

506  1116 
DeleteCI(t); 
856  1117 
t^.dX:= t^.dX + Gear^.dX * dmg * _0_01 + SignAs(cHHKick, Gear^.dX); 
506  1118 
t^.dY:= t^.dY + Gear^.dY * dmg * _0_01; 
1119 
t^.State:= t^.State or gstMoving; 

1120 
t^.Active:= true; 

1121 
FollowGear:= t 

1122 
end; 

1123 
gtGrave: begin 

1124 
t^.dY:=  _0_1; 

1125 
t^.Active:= true 

1126 
end; 

1127 
end; 

1128 
t:= t^.NextGear 

1129 
end; 

621  1130 
if (GameFlags and gfSolidLand) = 0 then DrawExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), cShotgunRadius) 
506  1131 
end; 
1132 

371  1133 
procedure AmmoShove(Ammo: PGear; Damage, Power: LongInt); 
53  1134 
var t: PGearArray; 
371  1135 
i: LongInt; 
38  1136 
begin 
53  1137 
t:= CheckGearsCollision(Ammo); 
351  1138 
i:= t^.Count; 
53  1139 
while i > 0 do 
981  1140 
begin 
1141 
dec(i); 

1142 
if (t^.ar[i]^.State and gstNoDamage) = 0 then 

1143 
case t^.ar[i]^.Kind of 

1144 
gtHedgehog, 

1145 
gtMine, 

1146 
gtTarget, 

1147 
gtCase: begin 

1148 
inc(t^.ar[i]^.Damage, Damage); 

1149 

1150 
if t^.ar[i]^.Kind = gtHedgehog then 

1151 
AddDamageTag(hwRound(t^.ar[i]^.X), hwRound(t^.ar[i]^.Y), Damage, t^.ar[i]); 

867  1152 

981  1153 
DeleteCI(t^.ar[i]); 
1154 
t^.ar[i]^.dX:= Ammo^.dX * Power * _0_01; 

1155 
t^.ar[i]^.dY:= Ammo^.dY * Power * _0_01; 

1156 
t^.ar[i]^.Active:= true; 

1157 
t^.ar[i]^.State:= t^.ar[i]^.State or gstMoving; 

867  1158 

982  1159 
if TestCollisionXwithGear(t^.ar[i], hwSign(t^.ar[i]^.dX)) then 
981  1160 
begin 
1161 
if not (TestCollisionXwithXYShift(t^.ar[i], _0, 3, hwSign(t^.ar[i]^.dX)) 

1162 
or TestCollisionYwithGear(t^.ar[i], 1)) then t^.ar[i]^.Y:= t^.ar[i]^.Y  _1; 

1163 
if not (TestCollisionXwithXYShift(t^.ar[i], _0, 2, hwSign(t^.ar[i]^.dX)) 

1164 
or TestCollisionYwithGear(t^.ar[i], 1)) then t^.ar[i]^.Y:= t^.ar[i]^.Y  _1; 

1165 
if not (TestCollisionXwithXYShift(t^.ar[i], _0, 1, hwSign(t^.ar[i]^.dX)) 

1166 
or TestCollisionYwithGear(t^.ar[i], 1)) then t^.ar[i]^.Y:= t^.ar[i]^.Y  _1; 

1167 
end; 

982  1168 

981  1169 
FollowGear:= t^.ar[i] 
1170 
end; 

1171 
end 

1172 
end; 

126  1173 
SetAllToActive 
38  1174 
end; 
1175 

4  1176 
procedure AssignHHCoords; 
955  1177 
var i, t, p, j: LongInt; 
543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
542
diff
changeset

1178 
ar: array[0..Pred(cMaxHHs)] of PGear; 
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
542
diff
changeset

1179 
Count: Longword; 
4  1180 
begin 
543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
542
diff
changeset

1181 
if (GameFlags and gfForts) <> 0 then 
955  1182 
begin 
1183 
t:= 0; 

1184 
for p:= 0 to 1 do 

1185 
begin 

1186 
with ClansArray[p]^ do 

1187 
for j:= 0 to Pred(TeamsNumber) do 

1188 
with Teams[j]^ do 

1189 
for i:= 0 to cMaxHHIndex do 

1190 
with Hedgehogs[i] do 

958  1191 
if (Gear <> nil) and (Gear^.X.QWordValue = 0) then 
1192 
begin 

1193 
FindPlace(Gear, false, t, t + 1024); 

999
8dcf263c9e8f
In forts mode, hedgehogs on the left look at the right, and viceversa
unc0rr
parents:
997
diff
changeset

1194 
Gear^.Pos:= GetRandom(19); 
8dcf263c9e8f
In forts mode, hedgehogs on the left look at the right, and viceversa
unc0rr
parents:
997
diff
changeset

1195 
Gear^.dX.isNegative:= p = 1; 
958  1196 
end; 
955  1197 
inc(t, 1024) 
1198 
end 

1199 
end else // mix hedgehogs 

1200 
begin 

1201 
Count:= 0; 

1202 
for p:= 0 to Pred(TeamsCount) do 

1203 
with TeamsArray[p]^ do 

1204 
begin 

1205 
for i:= 0 to cMaxHHIndex do 

1206 
with Hedgehogs[i] do 

1207 
if (Gear <> nil) and (Gear^.X.QWordValue = 0) then 

1208 
begin 

1209 
ar[Count]:= Gear; 

1210 
inc(Count) 

1211 
end; 

1212 
end; 

543
465e2ec8f05f
 Better randomness of placing hedgehogs on the land
unc0rr
parents:
542
diff
changeset

1213 

955  1214 
while (Count > 0) do 
1215 
begin 

1216 
i:= GetRandom(Count); 

1217 
FindPlace(ar[i], false, 0, 2048); 

1000
e7b204880318
Hedgehogs on the left side of the map look to the right and viceversa
unc0rr
parents:
999
diff
changeset

1218 
ar[i]^.dX.isNegative:= ar[i]^.X > _1024; 
959  1219 
ar[i]^.Pos:= GetRandom(19); 
955  1220 
ar[i]:= ar[Count  1]; 
1221 
dec(Count) 

1222 
end 

1223 
end 

4  1224 
end; 
1225 

371  1226 
function CheckGearNear(Gear: PGear; Kind: TGearType; rX, rY: LongInt): PGear; 
10  1227 
var t: PGear; 
1228 
begin 

1229 
t:= GearsList; 

1230 
rX:= sqr(rX); 

1231 
rY:= sqr(rY); 

1232 
while t <> nil do 

1233 
begin 

351  1234 
if (t <> Gear) and (t^.Kind = Kind) then 
498  1235 
if not((hwSqr(Gear^.X  t^.X) / rX + hwSqr(Gear^.Y  t^.Y) / rY) > _1) then 
351  1236 
exit(t); 
1237 
t:= t^.NextGear 

10  1238 
end; 
351  1239 
CheckGearNear:= nil 
15  1240 
end; 
1241 

79  1242 
procedure AmmoFlameWork(Ammo: PGear); 
1243 
var t: PGear; 

1244 
begin 

1245 
t:= GearsList; 

1246 
while t <> nil do 

1247 
begin 

351  1248 
if (t^.Kind = gtHedgehog) and (t^.Y < Ammo^.Y) then 
498  1249 
if not (hwSqr(Ammo^.X  t^.X) + hwSqr(Ammo^.Y  t^.Y  int2hwFloat(cHHRadius)) * 2 > _2) then 
79  1250 
begin 
351  1251 
inc(t^.Damage, 5); 
1252 
t^.dX:= t^.dX + (t^.X  Ammo^.X) * _0_02; 

1253 
t^.dY:=  _0_25; 

1254 
t^.Active:= true; 

79  1255 
DeleteCI(t); 
1256 
FollowGear:= t 

1257 
end; 

351  1258 
t:= t^.NextGear 
79  1259 
end; 
1260 
end; 

1261 

371  1262 
function CheckGearsNear(mX, mY: LongInt; Kind: TGearsType; rX, rY: LongInt): PGear; 
16  1263 
var t: PGear; 
1264 
begin 

1265 
t:= GearsList; 

1266 
rX:= sqr(rX); 

1267 
rY:= sqr(rY); 

1268 
while t <> nil do 

1269 
begin 

351  1270 
if t^.Kind in Kind then 
498  1271 
if not (hwSqr(int2hwFloat(mX)  t^.X) / rX + hwSqr(int2hwFloat(mY)  t^.Y) / rY > _1) then 
351  1272 
exit(t); 
1273 
t:= t^.NextGear 

16  1274 
end; 
351  1275 
CheckGearsNear:= nil 
16  1276 
end; 
1277 

1278 
function CountGears(Kind: TGearType): Longword; 

1279 
var t: PGear; 

351  1280 
Result: Longword; 
16  1281 
begin 
1282 
Result:= 0; 

1283 
t:= GearsList; 

1284 
while t <> nil do 

1285 
begin 

351  1286 
if t^.Kind = Kind then inc(Result); 
1287 
t:= t^.NextGear 

16  1288 
end; 
351  1289 
CountGears:= Result 
16  1290 
end; 
1291 

15  1292 
procedure SpawnBoxOfSmth; 
394
4c017ae1226a
 Implement hack to let ammo stores work without needed assistance of frontend
unc0rr
parents:
393
diff
changeset

1293 
var t: LongInt; 
4c017ae1226a
 Implement hack to let ammo stores work without needed assistance of frontend
unc0rr
parents:
393
diff
changeset

1294 
i: TAmmoType; 
15  1295 
begin 
614  1296 
if (cCaseFactor = 0) or 
1297 
(CountGears(gtCase) >= 5) or 

1298 
(getrandom(cCaseFactor) <> 0) then exit; 

498  1299 
FollowGear:= AddGear(0, 0, gtCase, 0, _0, _0, 0); 
295  1300 
case getrandom(2) of 
1301 
0: begin 

351  1302 
FollowGear^.Health:= 25; 
1303 
FollowGear^.Pos:= posCaseHealth 

295  1304 
end; 
1305 
1: begin 

394
4c017ae1226a
 Implement hack to let ammo stores work without needed assistance of frontend
unc0rr
parents:
393
diff
changeset

1306 
t:= 0; 
4c017ae1226a
 Implement hack to let ammo stores work without needed assistance of frontend
unc0rr
parents:
393
diff
changeset

1307 
for i:= Low(TAmmoType) to High(TAmmoType) do 
4c017ae1226a
 Implement hack to let ammo stores work without needed assistance of frontend
unc0rr
parents:
393
diff
changeset

1308 
inc(t, Ammoz[i].Probability); 
4c017ae1226a
 Implement hack to let ammo stores work without needed assistance of frontend
unc0rr
parents:
393
diff
changeset

1309 
t:= GetRandom(t); 
4c017ae1226a
 Implement hack to let ammo stores work without needed assistance of frontend
unc0rr
parents:
393
diff
changeset

1310 
i:= Low(TAmmoType); 
4c017ae1226a
 Implement hack to let ammo stores work without needed assistance of frontend
unc0rr
parents:
393
diff
changeset

1311 
dec(t, Ammoz[i].Probability); 
4c017ae1226a
 Implement hack to let ammo stores work without needed assistance of frontend
unc0rr
parents:
393
diff
changeset

1312 
while t >= 0 do 
4c017ae1226a
 Implement hack to let ammo stores work without needed assistance of frontend
unc0rr
parents:
393
diff
changeset

1313 
begin 
4c017ae1226a
 Implement hack to let ammo stores work without needed assistance of frontend
unc0rr
parents:
393
diff
changeset

1314 
inc(i); 
4c017ae1226a
 Implement hack to let ammo stores work without needed assistance of frontend
unc0rr
parents:
393
diff
changeset

1315 
dec(t, Ammoz[i].Probability) 
4c017ae1226a
 Implement hack to let ammo stores work without needed assistance of frontend
unc0rr
parents:
393
diff
changeset

1316 
end; 
865  1317 
PlaySound(sndReinforce, false); 
351  1318 
FollowGear^.Pos:= posCaseAmmo; 
394
4c017ae1226a
 Implement hack to let ammo stores work without needed assistance of frontend
unc0rr
parents:
393
diff
changeset

1319 
FollowGear^.State:= Longword(i) 
295  1320 
end; 
1321 
end; 

70  1322 
FindPlace(FollowGear, true, 0, 2048) 
1323 
end; 

1324 

371  1325 
procedure FindPlace(Gear: PGear; withFall: boolean; Left, Right: LongInt); 
70  1326 

371  1327 
function CountNonZeroz(x, y, r: LongInt): LongInt; 
1328 
var i: LongInt; 

1329 
Result: LongInt; 

70  1330 
begin 
1331 
Result:= 0; 

701  1332 
if (y and $FFFFFC00) = 0 then 
1333 
for i:= max(x  r, 0) to min(x + r, 2043) do 

351  1334 
if Land[y, i] <> 0 then inc(Result); 
1335 
CountNonZeroz:= Result 

70  1336 
end; 
1337 

495  1338 
var x: LongInt; 
371  1339 
y, sy: LongInt; 
386  1340 
ar: array[0..511] of TPoint; 
1341 
ar2: array[0..1023] of TPoint; 

392  1342 
cnt, cnt2: Longword; 
1343 
delta: LongInt; 

70  1344 
begin 
386  1345 
delta:= 250; 
1346 
cnt2:= 0; 

16  1347 
repeat 
392  1348 
x:= Left + LongInt(GetRandom(Delta)); 
70  1349 
repeat 
386  1350 
inc(x, Delta); 
70  1351 
cnt:= 0; 
351  1352 
y:= Gear^.Radius * 2; 
70  1353 
while y < 1023 do 
16  1354 
begin 
70  1355 
repeat 
701  1356 
inc(y, 2); 
351  1357 
until (y > 1023) or (CountNonZeroz(x, y, Gear^.Radius  1) = 0); 
70  1358 
sy:= y; 
1359 
repeat 

1360 
inc(y); 

351  1361 
until (y > 1023) or (CountNonZeroz(x, y, Gear^.Radius  1) <> 0); 
1362 
if (y  sy > Gear^.Radius * 2) 

70  1363 
and (y < 1023) 
351  1364 
and (CheckGearsNear(x, y  Gear^.Radius, [gtHedgehog, gtMine, gtCase], 110, 110) = nil) then 
70  1365 
begin 
1366 
ar[cnt].X:= x; 

351  1367 
if withFall then ar[cnt].Y:= sy + Gear^.Radius 
1368 
else ar[cnt].Y:= y  Gear^.Radius; 

70  1369 
inc(cnt) 
1370 
end; 

386  1371 
inc(y, 45) 
16  1372 
end; 
70  1373 
if cnt > 0 then 
1374 
with ar[GetRandom(cnt)] do 

1375 
begin 

386  1376 
ar2[cnt2].x:= x; 
1377 
ar2[cnt2].y:= y; 

1378 
inc(cnt2) 

70  1379 
end 
386  1380 
until (x + Delta > Right); 
1381 
dec(Delta, 60) 

