author | Xeli |
Sun, 21 Aug 2011 18:14:49 +0200 | |
branch | hedgeroid |
changeset 5625 | 9add7b92c5f0 |
parent 5594 | 3ab68a93434b |
child 5612 | 2638dec1b323 |
permissions | -rw-r--r-- |
4 | 1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
4976 | 3 |
* Copyright (c) 2004-2011 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 02111-1307, USA |
|
4 | 17 |
*) |
18 |
||
2622 | 19 |
{$INCLUDE "options.inc"} |
20 |
||
4 | 21 |
unit uGears; |
5121
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
22 |
(* |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
23 |
* This unit defines the behavior of gears. |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
24 |
* |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
25 |
* Gears are "things"/"objects" that may be visible to the player or not, |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
26 |
* but always have an effect on the course of the game. |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
27 |
* |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
28 |
* E.g.: weapons, hedgehogs, etc. |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
29 |
* |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
30 |
* Note: The visual appearance of gears is defined in the unit "uGearsRender". |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
31 |
* |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
32 |
* Note: Gears that do not have an effect on the game but are just visual |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
33 |
* effects are called "Visual Gears" and defined in the respective unit! |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
34 |
*) |
4 | 35 |
interface |
4385 | 36 |
uses SDLh, uConsts, uFloat, uTypes; |
3697 | 37 |
|
3038 | 38 |
procedure initModule; |
39 |
procedure freeModule; |
|
371 | 40 |
function AddGear(X, Y: LongInt; Kind: TGearType; State: Longword; dX, dY: hwFloat; Timer: LongWord): PGear; |
4976 | 41 |
function SpawnCustomCrateAt(x, y: LongInt; crate: TCrateType; content: Longword ): PGear; |
5343 | 42 |
function SpawnFakeCrateAt(x, y: LongInt; crate: TCrateType; explode: boolean; poison: boolean ): PGear; |
5584
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
43 |
function GetAmmo: TAmmoType; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
44 |
function GetUtility: TAmmoType; |
3768 | 45 |
procedure ResurrectHedgehog(gear: PGear); |
4 | 46 |
procedure ProcessGears; |
3396
e5b3e5f2818e
More portal changes. Allows for a multishoot utility. Hopefully not breaking anything.
nemo
parents:
3390
diff
changeset
|
47 |
procedure EndTurnCleanup; |
4837
2ea0a152c319
Pass PHedgehog instead of PGear to stats. Fixes crash.
unc0rr
parents:
4835
diff
changeset
|
48 |
procedure ApplyDamage(Gear: PGear; AttackerHog: PHedgehog; Damage: Longword; Source: TDamageSource); |
4 | 49 |
procedure SetAllToActive; |
50 |
procedure SetAllHHToActive; |
|
956 | 51 |
procedure DrawGears; |
4 | 52 |
procedure FreeGearsList; |
10 | 53 |
procedure AddMiscGears; |
4 | 54 |
procedure AssignHHCoords; |
3405 | 55 |
function GearByUID(uid : Longword) : PGear; |
294 | 56 |
procedure InsertGearToList(Gear: PGear); |
57 |
procedure RemoveGearFromList(Gear: PGear); |
|
3405 | 58 |
function ModifyDamage(dmg: Longword; Gear: PGear): Longword; |
4443
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
59 |
procedure FindPlace(var Gear: PGear; withFall: boolean; Left, Right: LongInt; skipProximity: boolean = false); |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
60 |
procedure DeleteGear(Gear: PGear); |
4385 | 61 |
|
4 | 62 |
|
63 |
implementation |
|
4393 | 64 |
uses uStore, uSound, uTeams, uRandom, uCollisions, uIO, uLandGraphics, |
4373 | 65 |
uAIMisc, uLocale, uAI, uAmmos, uStats, uVisualGears, uScript, GLunit, uMobile, uVariables, |
4611 | 66 |
uCommands, uUtils, uTextures, uRenderUtils, uGearsRender, uCaptions, uDebug, uLandTexture; |
789 | 67 |
|
3697 | 68 |
|
4837
2ea0a152c319
Pass PHedgehog instead of PGear to stats. Fixes crash.
unc0rr
parents:
4835
diff
changeset
|
69 |
procedure doMakeExplosion(X, Y, Radius: LongInt; AttackingHog: PHedgehog; Mask: Longword; const Tint: LongWord = $FFFFFFFF); forward; |
371 | 70 |
procedure AmmoShove(Ammo: PGear; Damage, Power: LongInt); forward; |
1433 | 71 |
//procedure AmmoFlameWork(Ammo: PGear); forward; |
4034
634a8c8682de
add some phone rumbling to big explosions, airbomb and sinegun
koda
parents:
4024
diff
changeset
|
72 |
function GearsNear(X, Y: hwFloat; Kind: TGearType; r: LongInt): TPGearArray; forward; |
371 | 73 |
function CheckGearNear(Gear: PGear; Kind: TGearType; rX, rY: LongInt): PGear; forward; |
15 | 74 |
procedure SpawnBoxOfSmth; forward; |
32
78bff13b11c0
With this patch the game doesn't crash when gaming by net
unc0rr
parents:
24
diff
changeset
|
75 |
procedure AfterAttack; forward; |
302 | 76 |
procedure HedgehogStep(Gear: PGear); forward; |
1528 | 77 |
procedure doStepHedgehogMoving(Gear: PGear); forward; |
5197
9fa96377a69c
Basic TARDIS implementation. Still needs proper animation, and probably a check to force reappearance on death of last team mate
nemo
parents:
5190
diff
changeset
|
78 |
procedure doStepHedgehogReturn(Gear: PGear); forward; |
4881
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4867
diff
changeset
|
79 |
procedure HedgehogChAngle(HHGear: PGear); forward; |
506 | 80 |
procedure ShotgunShot(Gear: PGear); forward; |
1689 | 81 |
procedure PickUp(HH, Gear: PGear); forward; |
4881
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4867
diff
changeset
|
82 |
procedure HHSetWeapon(HHGear: PGear); forward; |
2941
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2940
diff
changeset
|
83 |
procedure doStepCase(Gear: PGear); forward; |
1964 | 84 |
|
5121
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
85 |
// For better maintainability the step handlers of gears are stored in |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
86 |
// separate files. |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
87 |
// Note: step handlers of gears that are hedgehogs are in a different file |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
88 |
// than the handlers for all other gears. |
2599 | 89 |
{$INCLUDE "GSHandlers.inc"} |
90 |
{$INCLUDE "HHHandlers.inc"} |
|
4 | 91 |
|
92 |
const doStepHandlers: array[TGearType] of TGearStepProcedure = ( |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
93 |
@doStepBomb, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
94 |
@doStepHedgehog, |
4168 | 95 |
@doStepShell, |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
96 |
@doStepGrave, |
3080 | 97 |
@doStepBee, |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
98 |
@doStepShotgunShot, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
99 |
@doStepPickHammer, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
100 |
@doStepRope, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
101 |
@doStepMine, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
102 |
@doStepCase, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
103 |
@doStepDEagleShot, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
104 |
@doStepDynamite, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
105 |
@doStepBomb, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
106 |
@doStepCluster, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
107 |
@doStepShover, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
108 |
@doStepFlame, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
109 |
@doStepFirePunch, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
110 |
@doStepActionTimer, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
111 |
@doStepActionTimer, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
112 |
@doStepParachute, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
113 |
@doStepAirAttack, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
114 |
@doStepAirBomb, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
115 |
@doStepBlowTorch, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
116 |
@doStepGirder, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
117 |
@doStepTeleport, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
118 |
@doStepSwitcher, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
119 |
@doStepTarget, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
120 |
@doStepMortar, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
121 |
@doStepWhip, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
122 |
@doStepKamikaze, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
123 |
@doStepCake, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
124 |
@doStepSeduction, |
5313
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
125 |
@doStepBomb, |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
126 |
@doStepCluster, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
127 |
@doStepBomb, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
128 |
@doStepWaterUp, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
129 |
@doStepDrill, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
130 |
@doStepBallgun, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
131 |
@doStepBomb, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
132 |
@doStepRCPlane, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
133 |
@doStepSniperRifleShot, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
134 |
@doStepJetpack, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
135 |
@doStepMolotov, |
2983 | 136 |
@doStepCase, |
3032 | 137 |
@doStepBirdy, |
3342
b4f01613dcd7
Some initial stubs for portal just so Tiy will quit nagging. Also let folks know what approximation of physics I plan to try, here.
nemo
parents:
3337
diff
changeset
|
138 |
@doStepEggWork, |
3428 | 139 |
@doStepPortalShot, |
3382 | 140 |
@doStepPiano, |
3384 | 141 |
@doStepBomb, |
3476
1ec68b8d3bd1
Henek adds a flamethrower, updates some translations, and tweaks how fire works.
nemo
parents:
3475
diff
changeset
|
142 |
@doStepSineGunShot, |
3710 | 143 |
@doStepFlamethrower, |
3712 | 144 |
@doStepSMine, |
3717 | 145 |
@doStepPoisonCloud, |
3720 | 146 |
@doStepHammer, |
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
147 |
@doStepHammerHit, |
4313
0690067bc5ff
made napalm use napalmbombs instead of just dropping fire
Henek
parents:
4299
diff
changeset
|
148 |
@doStepResurrector, |
4578 | 149 |
@doStepNapalmBomb, |
4611 | 150 |
@doStepSnowball, |
4881
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4867
diff
changeset
|
151 |
@doStepSnowflake, |
5279 | 152 |
@doStepStructure, |
5197
9fa96377a69c
Basic TARDIS implementation. Still needs proper animation, and probably a check to force reappearance on death of last team mate
nemo
parents:
5190
diff
changeset
|
153 |
@doStepLandGun, |
9fa96377a69c
Basic TARDIS implementation. Still needs proper animation, and probably a check to force reappearance on death of last team mate
nemo
parents:
5190
diff
changeset
|
154 |
@doStepTardis); |
4 | 155 |
|
294 | 156 |
procedure InsertGearToList(Gear: PGear); |
803 | 157 |
var tmp, ptmp: PGear; |
294 | 158 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
159 |
tmp:= GearsList; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
160 |
ptmp:= GearsList; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
161 |
while (tmp <> nil) and (tmp^.Z <= Gear^.Z) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
162 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
163 |
ptmp:= tmp; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
164 |
tmp:= tmp^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
165 |
end; |
3697 | 166 |
|
3442 | 167 |
if ptmp <> tmp then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
168 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
169 |
Gear^.NextGear:= ptmp^.NextGear; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
170 |
Gear^.PrevGear:= ptmp; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
171 |
if ptmp^.NextGear <> nil then ptmp^.NextGear^.PrevGear:= Gear; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
172 |
ptmp^.NextGear:= Gear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
173 |
end |
3442 | 174 |
else |
175 |
begin |
|
176 |
Gear^.NextGear:= GearsList; |
|
177 |
if Gear^.NextGear <> nil then Gear^.NextGear^.PrevGear:= Gear; |
|
178 |
GearsList:= Gear; |
|
179 |
end; |
|
294 | 180 |
end; |
181 |
||
182 |
procedure RemoveGearFromList(Gear: PGear); |
|
183 |
begin |
|
351 | 184 |
if Gear^.NextGear <> nil then Gear^.NextGear^.PrevGear:= Gear^.PrevGear; |
1505 | 185 |
if Gear^.PrevGear <> nil then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
186 |
Gear^.PrevGear^.NextGear:= Gear^.NextGear |
1505 | 187 |
else |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
188 |
GearsList:= Gear^.NextGear |
294 | 189 |
end; |
190 |
||
3443
14d12df0d363
finishing the gtHealthTag -> vgtHealthTag, no segfaults and hogzombies no more, hopefully
sheepluva
parents:
3442
diff
changeset
|
191 |
procedure spawnHealthTagForHH(HHGear: PGear; dmg: Longword); |
14d12df0d363
finishing the gtHealthTag -> vgtHealthTag, no segfaults and hogzombies no more, hopefully
sheepluva
parents:
3442
diff
changeset
|
192 |
var tag: PVisualGear; |
14d12df0d363
finishing the gtHealthTag -> vgtHealthTag, no segfaults and hogzombies no more, hopefully
sheepluva
parents:
3442
diff
changeset
|
193 |
begin |
3459
c552aa44108d
hey sheepluva, how about just this? lets you have an anonymous one too.
nemo
parents:
3453
diff
changeset
|
194 |
tag:= AddVisualGear(hwRound(HHGear^.X), hwRound(HHGear^.Y), vgtHealthTag, dmg); |
c552aa44108d
hey sheepluva, how about just this? lets you have an anonymous one too.
nemo
parents:
3453
diff
changeset
|
195 |
if (tag <> nil) then |
4372 | 196 |
tag^.Hedgehog:= HHGear^.Hedgehog; // the tag needs the tag to determine the text color |
3443
14d12df0d363
finishing the gtHealthTag -> vgtHealthTag, no segfaults and hogzombies no more, hopefully
sheepluva
parents:
3442
diff
changeset
|
197 |
AllInactive:= false; |
14d12df0d363
finishing the gtHealthTag -> vgtHealthTag, no segfaults and hogzombies no more, hopefully
sheepluva
parents:
3442
diff
changeset
|
198 |
HHGear^.Active:= true; |
14d12df0d363
finishing the gtHealthTag -> vgtHealthTag, no segfaults and hogzombies no more, hopefully
sheepluva
parents:
3442
diff
changeset
|
199 |
end; |
14d12df0d363
finishing the gtHealthTag -> vgtHealthTag, no segfaults and hogzombies no more, hopefully
sheepluva
parents:
3442
diff
changeset
|
200 |
|
371 | 201 |
function AddGear(X, Y: LongInt; Kind: TGearType; State: Longword; dX, dY: hwFloat; Timer: LongWord): PGear; |
79 | 202 |
const Counter: Longword = 0; |
2695 | 203 |
var gear: PGear; |
4 | 204 |
begin |
79 | 205 |
inc(Counter); |
3337 | 206 |
AddFileLog('AddGear: #' + inttostr(Counter) + ' (' + inttostr(x) + ',' + inttostr(y) + '), d(' + floattostr(dX) + ',' + floattostr(dY) + ') type = ' + EnumToStr(Kind)); |
1495 | 207 |
|
2695 | 208 |
New(gear); |
209 |
FillChar(gear^, sizeof(TGear), 0); |
|
210 |
gear^.X:= int2hwFloat(X); |
|
211 |
gear^.Y:= int2hwFloat(Y); |
|
5507
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5501
diff
changeset
|
212 |
gear^.TargetX:= NoPointX; |
2695 | 213 |
gear^.Kind := Kind; |
214 |
gear^.State:= State; |
|
215 |
gear^.Active:= true; |
|
216 |
gear^.dX:= dX; |
|
217 |
gear^.dY:= dY; |
|
218 |
gear^.doStep:= doStepHandlers[Kind]; |
|
219 |
gear^.CollisionIndex:= -1; |
|
220 |
gear^.Timer:= Timer; |
|
221 |
gear^.Z:= cUsualZ; |
|
222 |
gear^.FlightTime:= 0; |
|
223 |
gear^.uid:= Counter; |
|
2745 | 224 |
gear^.SoundChannel:= -1; |
3094
97c8406acc85
making collision/impact sounds a gear property + adding random melon+hellish sound, feel free to hate me :D
sheepluva
parents:
3086
diff
changeset
|
225 |
gear^.ImpactSound:= sndNone; |
3136 | 226 |
gear^.nImpactSounds:= 0; |
5351 | 227 |
// Define ammo association, if any. |
228 |
gear^.AmmoType:= GearKindAmmoTypeMap[Kind]; |
|
505
fcba7d7aea0d
Fix old bug with grenade(bomd, etc..) not colliding with attacking hedgehog
unc0rr
parents:
503
diff
changeset
|
229 |
|
4837
2ea0a152c319
Pass PHedgehog instead of PGear to stats. Fixes crash.
unc0rr
parents:
4835
diff
changeset
|
230 |
if CurrentHedgehog <> nil then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
231 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
232 |
gear^.Hedgehog:= CurrentHedgehog; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
233 |
gear^.IntersectGear:= CurrentHedgehog^.Gear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
234 |
end; |
5351 | 235 |
|
4 | 236 |
case Kind of |
5137
b6140f35735f
rename gtBomb to gtGrenade, nerf grenade from 50 to 47 pending some flag to indicate pixels in Land[] belonging to current hog to avoid throwing grenades into hogs
nemo
parents:
5121
diff
changeset
|
237 |
gtGrenade, |
3382 | 238 |
gtClusterBomb, |
239 |
gtGasBomb: begin |
|
3094
97c8406acc85
making collision/impact sounds a gear property + adding random melon+hellish sound, feel free to hate me :D
sheepluva
parents:
3086
diff
changeset
|
240 |
gear^.ImpactSound:= sndGrenadeImpact; |
3136 | 241 |
gear^.nImpactSounds:= 1; |
3072
b18038b3a0f4
I don't know why I'm bothering. Sheepluva has a whole new approach in the works.
nemo
parents:
3065
diff
changeset
|
242 |
gear^.AdvBounce:= 1; |
4299 | 243 |
gear^.Radius:= 5; |
3475 | 244 |
gear^.Elasticity:= _0_8; |
245 |
gear^.Friction:= _0_8; |
|
4602
ec84fb564bab
added density for gears used in gfMoreWind, needs alot of tweaking
Henek
parents:
4578
diff
changeset
|
246 |
gear^.Density:= _1_5; |
2695 | 247 |
gear^.RenderTimer:= true; |
248 |
if gear^.Timer = 0 then gear^.Timer:= 3000 |
|
4 | 249 |
end; |
1261 | 250 |
gtWatermelon: begin |
3094
97c8406acc85
making collision/impact sounds a gear property + adding random melon+hellish sound, feel free to hate me :D
sheepluva
parents:
3086
diff
changeset
|
251 |
gear^.ImpactSound:= sndMelonImpact; |
3136 | 252 |
gear^.nImpactSounds:= 1; |
3072
b18038b3a0f4
I don't know why I'm bothering. Sheepluva has a whole new approach in the works.
nemo
parents:
3065
diff
changeset
|
253 |
gear^.AdvBounce:= 1; |
4299 | 254 |
gear^.Radius:= 6; |
2695 | 255 |
gear^.Elasticity:= _0_8; |
256 |
gear^.Friction:= _0_995; |
|
4602
ec84fb564bab
added density for gears used in gfMoreWind, needs alot of tweaking
Henek
parents:
4578
diff
changeset
|
257 |
gear^.Density:= _2; |
2695 | 258 |
gear^.RenderTimer:= true; |
259 |
if gear^.Timer = 0 then gear^.Timer:= 3000 |
|
1261 | 260 |
end; |
4602
ec84fb564bab
added density for gears used in gfMoreWind, needs alot of tweaking
Henek
parents:
4578
diff
changeset
|
261 |
gtMelonPiece: begin |
ec84fb564bab
added density for gears used in gfMoreWind, needs alot of tweaking
Henek
parents:
4578
diff
changeset
|
262 |
gear^.Density:= _2; |
ec84fb564bab
added density for gears used in gfMoreWind, needs alot of tweaking
Henek
parents:
4578
diff
changeset
|
263 |
end; |
4 | 264 |
gtHedgehog: begin |
3072
b18038b3a0f4
I don't know why I'm bothering. Sheepluva has a whole new approach in the works.
nemo
parents:
3065
diff
changeset
|
265 |
gear^.AdvBounce:= 1; |
2695 | 266 |
gear^.Radius:= cHHRadius; |
267 |
gear^.Elasticity:= _0_35; |
|
268 |
gear^.Friction:= _0_999; |
|
269 |
gear^.Angle:= cMaxAngle div 2; |
|
4641 | 270 |
gear^.Density:= _3; |
2695 | 271 |
gear^.Z:= cHHZ; |
3768 | 272 |
if (GameFlags and gfAISurvival) <> 0 then |
4372 | 273 |
if gear^.Hedgehog^.BotLevel > 0 then |
274 |
gear^.Hedgehog^.Effects[heResurrectable] := true; |
|
4 | 275 |
end; |
4168 | 276 |
gtShell: begin |
2695 | 277 |
gear^.Radius:= 4; |
4602
ec84fb564bab
added density for gears used in gfMoreWind, needs alot of tweaking
Henek
parents:
4578
diff
changeset
|
278 |
gear^.Density:= _1; |
4 | 279 |
end; |
4578 | 280 |
gtSnowball: begin |
5493 | 281 |
gear^.ImpactSound:= sndMudballImpact; |
282 |
gear^.nImpactSounds:= 1; |
|
4705
593ef1ad3cd3
ok. restore old [r + 1 + r] for gear width for a moment, and reset snowballs.
nemo
parents:
4704
diff
changeset
|
283 |
gear^.Radius:= 4; |
4578 | 284 |
gear^.Elasticity:= _1; |
285 |
gear^.Friction:= _1; |
|
4602
ec84fb564bab
added density for gears used in gfMoreWind, needs alot of tweaking
Henek
parents:
4578
diff
changeset
|
286 |
gear^.Density:= _0_5; |
4578 | 287 |
end; |
4611 | 288 |
|
289 |
gtFlake: begin |
|
290 |
with Gear^ do |
|
291 |
begin |
|
5024 | 292 |
Radius:= 1; |
4611 | 293 |
DirAngle:= random * 360; |
294 |
dx.isNegative:= GetRandom(2) = 0; |
|
295 |
dx.QWordValue:= GetRandom(100000000); |
|
296 |
dy.isNegative:= false; |
|
297 |
dy.QWordValue:= GetRandom(70000000); |
|
5348
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset
|
298 |
State:= State or gstInvisible; |
4611 | 299 |
if GetRandom(2) = 0 then dx := -dx; |
300 |
Health:= random(vobFrameTicks); |
|
301 |
Timer:= random(vobFramesCount); |
|
302 |
Angle:= (random(2) * 2 - 1) * (1 + random(10000)) * vobVelocity |
|
303 |
end |
|
304 |
end; |
|
4 | 305 |
gtGrave: begin |
3094
97c8406acc85
making collision/impact sounds a gear property + adding random melon+hellish sound, feel free to hate me :D
sheepluva
parents:
3086
diff
changeset
|
306 |
gear^.ImpactSound:= sndGraveImpact; |
3136 | 307 |
gear^.nImpactSounds:= 1; |
2695 | 308 |
gear^.Radius:= 10; |
309 |
gear^.Elasticity:= _0_6; |
|
4 | 310 |
end; |
3080 | 311 |
gtBee: begin |
2695 | 312 |
gear^.Radius:= 5; |
313 |
gear^.Timer:= 500; |
|
314 |
gear^.RenderTimer:= true; |
|
3039 | 315 |
gear^.Elasticity:= _0_9; |
316 |
gear^.Tag:= getRandom(32); |
|
4 | 317 |
end; |
5525 | 318 |
gtSeduction: begin |
319 |
gear^.Radius:= 250; |
|
320 |
end; |
|
4 | 321 |
gtShotgunShot: begin |
2695 | 322 |
gear^.Timer:= 900; |
323 |
gear^.Radius:= 2 |
|
4 | 324 |
end; |
325 |
gtPickHammer: begin |
|
2695 | 326 |
gear^.Radius:= 10; |
327 |
gear^.Timer:= 4000 |
|
4 | 328 |
end; |
3720 | 329 |
gtHammerHit: begin |
330 |
gear^.Radius:= 8; |
|
331 |
gear^.Timer:= 125 |
|
332 |
end; |
|
4 | 333 |
gtRope: begin |
2695 | 334 |
gear^.Radius:= 3; |
4406
beb4de0af990
Increase teams to 8 to match the 8 colours, fix issue #108, reenable rope length modifier
nemo
parents:
4403
diff
changeset
|
335 |
gear^.Friction:= _450 * _0_01 * cRopePercent; |
4 | 336 |
RopePoints.Count:= 0; |
337 |
end; |
|
10 | 338 |
gtMine: begin |
5493 | 339 |
gear^.ImpactSound:= sndMineImpact; |
340 |
gear^.nImpactSounds:= 1; |
|
2882 | 341 |
gear^.Health:= 10; |
2695 | 342 |
gear^.State:= gear^.State or gstMoving; |
343 |
gear^.Radius:= 2; |
|
344 |
gear^.Elasticity:= _0_55; |
|
345 |
gear^.Friction:= _0_995; |
|
4602
ec84fb564bab
added density for gears used in gfMoreWind, needs alot of tweaking
Henek
parents:
4578
diff
changeset
|
346 |
gear^.Density:= _0_9; |
2031
b6f3e56fb100
david_ac's game scheme options for mine delay/quantity, tweaks to sniper rifle
nemo
parents:
2028
diff
changeset
|
347 |
if cMinesTime < 0 then |
4248 | 348 |
gear^.Timer:= getrandom(51)*100 |
2031
b6f3e56fb100
david_ac's game scheme options for mine delay/quantity, tweaks to sniper rifle
nemo
parents:
2028
diff
changeset
|
349 |
else |
4482 | 350 |
gear^.Timer:= cMinesTime; |
10 | 351 |
end; |
3710 | 352 |
gtSMine: begin |
353 |
gear^.Health:= 10; |
|
354 |
gear^.State:= gear^.State or gstMoving; |
|
355 |
gear^.Radius:= 2; |
|
356 |
gear^.Elasticity:= _0_55; |
|
357 |
gear^.Friction:= _0_995; |
|
4602
ec84fb564bab
added density for gears used in gfMoreWind, needs alot of tweaking
Henek
parents:
4578
diff
changeset
|
358 |
gear^.Density:= _0_9; |
3710 | 359 |
gear^.Timer:= 500; |
360 |
end; |
|
14
81f125629b25
- Mine checks whether a hedgehog is near less frequently
unc0rr
parents:
10
diff
changeset
|
361 |
gtCase: begin |
3094
97c8406acc85
making collision/impact sounds a gear property + adding random melon+hellish sound, feel free to hate me :D
sheepluva
parents:
3086
diff
changeset
|
362 |
gear^.ImpactSound:= sndGraveImpact; |
3136 | 363 |
gear^.nImpactSounds:= 1; |
2695 | 364 |
gear^.Radius:= 16; |
365 |
gear^.Elasticity:= _0_3 |
|
14
81f125629b25
- Mine checks whether a hedgehog is near less frequently
unc0rr
parents:
10
diff
changeset
|
366 |
end; |
2911 | 367 |
gtExplosives: begin |
3094
97c8406acc85
making collision/impact sounds a gear property + adding random melon+hellish sound, feel free to hate me :D
sheepluva
parents:
3086
diff
changeset
|
368 |
gear^.ImpactSound:= sndGrenadeImpact; |
3136 | 369 |
gear^.nImpactSounds:= 1; |
2911 | 370 |
gear^.Radius:= 16; |
2933 | 371 |
gear^.Elasticity:= _0_4; |
2938 | 372 |
gear^.Friction:= _0_995; |
4641 | 373 |
gear^.Density:= _6; |
2911 | 374 |
gear^.Health:= cBarrelHealth |
375 |
end; |
|
37 | 376 |
gtDEagleShot: begin |
2695 | 377 |
gear^.Radius:= 1; |
378 |
gear^.Health:= 50 |
|
37 | 379 |
end; |
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
380 |
gtSniperRifleShot: begin |
2695 | 381 |
gear^.Radius:= 1; |
382 |
gear^.Health:= 50 |
|
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
383 |
end; |
39 | 384 |
gtDynamite: begin |
2695 | 385 |
gear^.Radius:= 3; |
386 |
gear^.Elasticity:= _0_55; |
|
387 |
gear^.Friction:= _0_03; |
|
4641 | 388 |
gear^.Density:= _2; |
2695 | 389 |
gear^.Timer:= 5000; |
39 | 390 |
end; |
2204
526f8165acce
Smaxx' idea of timers, reworked just a tad. Might need variable for offset, but seems ok for now
nemo
parents:
2186
diff
changeset
|
391 |
gtCluster: begin |
2695 | 392 |
gear^.Radius:= 2; |
4641 | 393 |
gear^.Density:= _1_5; |
2695 | 394 |
gear^.RenderTimer:= true |
2204
526f8165acce
Smaxx' idea of timers, reworked just a tad. Might need variable for offset, but seems ok for now
nemo
parents:
2186
diff
changeset
|
395 |
end; |
2695 | 396 |
gtShover: gear^.Radius:= 20; |
79 | 397 |
gtFlame: begin |
2695 | 398 |
gear^.Tag:= GetRandom(32); |
399 |
gear^.Radius:= 1; |
|
400 |
gear^.Health:= 5; |
|
4641 | 401 |
gear^.Density:= _1; |
2695 | 402 |
if (gear^.dY.QWordValue = 0) and (gear^.dX.QWordValue = 0) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
403 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
404 |
gear^.dY:= (getrandom - _0_8) * _0_03; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
405 |
gear^.dX:= (getrandom - _0_5) * _0_4 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
406 |
end |
79 | 407 |
end; |
82 | 408 |
gtFirePunch: begin |
2695 | 409 |
gear^.Radius:= 15; |
410 |
gear^.Tag:= Y |
|
82 | 411 |
end; |
302 | 412 |
gtAirBomb: begin |
2695 | 413 |
gear^.Radius:= 5; |
4641 | 414 |
gear^.Density:= _2; |
302 | 415 |
end; |
416 |
gtBlowTorch: begin |
|
2695 | 417 |
gear^.Radius:= cHHRadius + cBlowTorchC; |
418 |
gear^.Timer:= 7500 |
|
302 | 419 |
end; |
540 | 420 |
gtSwitcher: begin |
2695 | 421 |
gear^.Z:= cCurrHHZ |
540 | 422 |
end; |
593 | 423 |
gtTarget: begin |
3271 | 424 |
gear^.ImpactSound:= sndGrenadeImpact; |
425 |
gear^.nImpactSounds:= 1; |
|
2695 | 426 |
gear^.Radius:= 10; |
427 |
gear^.Elasticity:= _0_3; |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
428 |
gear^.Timer:= 0 |
593 | 429 |
end; |
924 | 430 |
gtMortar: begin |
2695 | 431 |
gear^.Radius:= 4; |
432 |
gear^.Elasticity:= _0_2; |
|
4602
ec84fb564bab
added density for gears used in gfMoreWind, needs alot of tweaking
Henek
parents:
4578
diff
changeset
|
433 |
gear^.Friction:= _0_08; |
ec84fb564bab
added density for gears used in gfMoreWind, needs alot of tweaking
Henek
parents:
4578
diff
changeset
|
434 |
gear^.Density:= _1; |
924 | 435 |
end; |
2695 | 436 |
gtWhip: gear^.Radius:= 20; |
3717 | 437 |
gtHammer: gear^.Radius:= 20; |
984 | 438 |
gtKamikaze: begin |
2695 | 439 |
gear^.Health:= 2048; |
440 |
gear^.Radius:= 20 |
|
984 | 441 |
end; |
1089 | 442 |
gtCake: begin |
2695 | 443 |
gear^.Health:= 2048; |
444 |
gear^.Radius:= 7; |
|
445 |
gear^.Z:= cOnHHZ; |
|
446 |
gear^.RenderTimer:= true; |
|
3508
a7ca07614a2d
correct cake sit-down animation so that it doesn't sit down in mid-air anymore
sheepluva
parents:
3499
diff
changeset
|
447 |
gear^.DirAngle:= -90 * hwSign(Gear^.dX); |
2695 | 448 |
if not dX.isNegative then gear^.Angle:= 1 else gear^.Angle:= 3 |
1089 | 449 |
end; |
1263 | 450 |
gtHellishBomb: begin |
3136 | 451 |
gear^.ImpactSound:= sndHellishImpact1; |
452 |
gear^.nImpactSounds:= 4; |
|
3072
b18038b3a0f4
I don't know why I'm bothering. Sheepluva has a whole new approach in the works.
nemo
parents:
3065
diff
changeset
|
453 |
gear^.AdvBounce:= 1; |
2695 | 454 |
gear^.Radius:= 4; |
455 |
gear^.Elasticity:= _0_5; |
|
456 |
gear^.Friction:= _0_96; |
|
4602
ec84fb564bab
added density for gears used in gfMoreWind, needs alot of tweaking
Henek
parents:
4578
diff
changeset
|
457 |
gear^.Density:= _1_5; |
2695 | 458 |
gear^.RenderTimer:= true; |
459 |
gear^.Timer:= 5000 |
|
1263 | 460 |
end; |
1573 | 461 |
gtDrill: begin |
4867
e604ee83e34f
let players set timer of drill strike. yes. drill strike :3 the timer starts to tick on first impact
sheepluva
parents:
4837
diff
changeset
|
462 |
if gear^.Timer = 0 then gear^.Timer:= 5000; |
e604ee83e34f
let players set timer of drill strike. yes. drill strike :3 the timer starts to tick on first impact
sheepluva
parents:
4837
diff
changeset
|
463 |
// Tag for drill strike. if 1 then first impact occured already |
e604ee83e34f
let players set timer of drill strike. yes. drill strike :3 the timer starts to tick on first impact
sheepluva
parents:
4837
diff
changeset
|
464 |
gear^.Tag := 0; |
4602
ec84fb564bab
added density for gears used in gfMoreWind, needs alot of tweaking
Henek
parents:
4578
diff
changeset
|
465 |
gear^.Radius:= 4; |
ec84fb564bab
added density for gears used in gfMoreWind, needs alot of tweaking
Henek
parents:
4578
diff
changeset
|
466 |
gear^.Density:= _1; |
1573 | 467 |
end; |
1601 | 468 |
gtBall: begin |
3094
97c8406acc85
making collision/impact sounds a gear property + adding random melon+hellish sound, feel free to hate me :D
sheepluva
parents:
3086
diff
changeset
|
469 |
gear^.ImpactSound:= sndGrenadeImpact; |
3136 | 470 |
gear^.nImpactSounds:= 1; |
3072
b18038b3a0f4
I don't know why I'm bothering. Sheepluva has a whole new approach in the works.
nemo
parents:
3065
diff
changeset
|
471 |
gear^.AdvBounce:= 1; |
2695 | 472 |
gear^.Radius:= 5; |
473 |
gear^.Tag:= random(8); |
|
474 |
gear^.Timer:= 5000; |
|
475 |
gear^.Elasticity:= _0_7; |
|
476 |
gear^.Friction:= _0_995; |
|
4602
ec84fb564bab
added density for gears used in gfMoreWind, needs alot of tweaking
Henek
parents:
4578
diff
changeset
|
477 |
gear^.Density:= _1_5; |
1601 | 478 |
end; |
479 |
gtBallgun: begin |
|
2695 | 480 |
gear^.Timer:= 5001; |
1601 | 481 |
end; |
1689 | 482 |
gtRCPlane: begin |
2695 | 483 |
gear^.Timer:= 15000; |
484 |
gear^.Health:= 3; |
|
485 |
gear^.Radius:= 8 |
|
1689 | 486 |
end; |
2177
c045698e044f
Initial attempt at jetpack. Pluses, more like lunar lander (takes fall damage). Minuses, can't seem to cancel it or use alt weapon
nemo
parents:
2168
diff
changeset
|
487 |
gtJetpack: begin |
2695 | 488 |
gear^.Health:= 2000; |
4260
472fd2fc1f31
Also switch saucer from updating every N ticks to updating as-needed.
nemo
parents:
4258
diff
changeset
|
489 |
gear^.Damage:= 100 |
2177
c045698e044f
Initial attempt at jetpack. Pluses, more like lunar lander (takes fall damage). Minuses, can't seem to cancel it or use alt weapon
nemo
parents:
2168
diff
changeset
|
490 |
end; |
3697 | 491 |
gtMolotov: begin |
2968
f59631c3c1c0
Fix iluvu flag (indexed), shrink molotov radius a bit to try and reduce fail
nemo
parents:
2964
diff
changeset
|
492 |
gear^.Radius:= 6; |
4602
ec84fb564bab
added density for gears used in gfMoreWind, needs alot of tweaking
Henek
parents:
4578
diff
changeset
|
493 |
gear^.Density:= _2; |
2488 | 494 |
end; |
2983 | 495 |
gtBirdy: begin |
496 |
gear^.Radius:= 16; // todo: check |
|
3149 | 497 |
gear^.Timer:= 0; |
3115 | 498 |
gear^.Health := 2000; |
3065 | 499 |
gear^.FlightTime := 2; |
2983 | 500 |
end; |
3697 | 501 |
gtEgg: begin |
3065 | 502 |
gear^.Radius:= 4; |
503 |
gear^.Elasticity:= _0_6; |
|
504 |
gear^.Friction:= _0_96; |
|
4602
ec84fb564bab
added density for gears used in gfMoreWind, needs alot of tweaking
Henek
parents:
4578
diff
changeset
|
505 |
gear^.Density:= _1; |
3065 | 506 |
if gear^.Timer = 0 then gear^.Timer:= 3000 |
507 |
end; |
|
3342
b4f01613dcd7
Some initial stubs for portal just so Tiy will quit nagging. Also let folks know what approximation of physics I plan to try, here.
nemo
parents:
3337
diff
changeset
|
508 |
gtPortal: begin |
b4f01613dcd7
Some initial stubs for portal just so Tiy will quit nagging. Also let folks know what approximation of physics I plan to try, here.
nemo
parents:
3337
diff
changeset
|
509 |
gear^.ImpactSound:= sndMelonImpact; |
b4f01613dcd7
Some initial stubs for portal just so Tiy will quit nagging. Also let folks know what approximation of physics I plan to try, here.
nemo
parents:
3337
diff
changeset
|
510 |
gear^.nImpactSounds:= 1; |
b4f01613dcd7
Some initial stubs for portal just so Tiy will quit nagging. Also let folks know what approximation of physics I plan to try, here.
nemo
parents:
3337
diff
changeset
|
511 |
gear^.AdvBounce:= 0; |
5594 | 512 |
gear^.Radius:= 17; |
4790 | 513 |
// set color |
514 |
gear^.Tag:= 2 * gear^.Timer; |
|
3428 | 515 |
gear^.Timer:= 15000; |
516 |
gear^.RenderTimer:= false; |
|
517 |
gear^.Health:= 100; |
|
3342
b4f01613dcd7
Some initial stubs for portal just so Tiy will quit nagging. Also let folks know what approximation of physics I plan to try, here.
nemo
parents:
3337
diff
changeset
|
518 |
end; |
3350 | 519 |
gtPiano: begin |
4602
ec84fb564bab
added density for gears used in gfMoreWind, needs alot of tweaking
Henek
parents:
4578
diff
changeset
|
520 |
gear^.Radius:= 32; |
ec84fb564bab
added density for gears used in gfMoreWind, needs alot of tweaking
Henek
parents:
4578
diff
changeset
|
521 |
gear^.Density:= _50; |
3350 | 522 |
end; |
3384 | 523 |
gtSineGunShot: begin |
524 |
gear^.Radius:= 5; |
|
525 |
gear^.Health:= 6000; |
|
526 |
end; |
|
3476
1ec68b8d3bd1
Henek adds a flamethrower, updates some translations, and tweaks how fire works.
nemo
parents:
3475
diff
changeset
|
527 |
gtFlamethrower: begin |
3485 | 528 |
gear^.Tag:= 10; |
529 |
gear^.Timer:= 10; |
|
530 |
gear^.Health:= 500; |
|
4258 | 531 |
gear^.Damage:= 100; |
3476
1ec68b8d3bd1
Henek adds a flamethrower, updates some translations, and tweaks how fire works.
nemo
parents:
3475
diff
changeset
|
532 |
end; |
5024 | 533 |
gtLandGun: begin |
534 |
gear^.Tag:= 10; |
|
535 |
gear^.Timer:= 10; |
|
536 |
gear^.Health:= 1000; |
|
537 |
gear^.Damage:= 100; |
|
538 |
end; |
|
3712 | 539 |
gtPoisonCloud: begin |
540 |
gear^.Timer:= 5000; |
|
3976 | 541 |
gear^.dY:= int2hwfloat(-4 + longint(getRandom(8))) / 1000; |
3712 | 542 |
end; |
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
543 |
gtResurrector: begin |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
544 |
gear^.Radius := 100; |
4265
039b08012887
distribute health evenly amongst graves instead of randomly - avoid situation where a grave stays dead
nemo
parents:
4260
diff
changeset
|
545 |
gear^.Tag := 0 |
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
546 |
end; |
4153
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
547 |
gtWaterUp: begin |
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
548 |
gear^.Tag := 47; |
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
549 |
end; |
4313
0690067bc5ff
made napalm use napalmbombs instead of just dropping fire
Henek
parents:
4299
diff
changeset
|
550 |
gtNapalmBomb: begin |
0690067bc5ff
made napalm use napalmbombs instead of just dropping fire
Henek
parents:
4299
diff
changeset
|
551 |
gear^.Timer:= 1000; |
0690067bc5ff
made napalm use napalmbombs instead of just dropping fire
Henek
parents:
4299
diff
changeset
|
552 |
gear^.Radius:= 5; |
4602
ec84fb564bab
added density for gears used in gfMoreWind, needs alot of tweaking
Henek
parents:
4578
diff
changeset
|
553 |
gear^.Density:= _1_5; |
4313
0690067bc5ff
made napalm use napalmbombs instead of just dropping fire
Henek
parents:
4299
diff
changeset
|
554 |
end; |
4881
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4867
diff
changeset
|
555 |
gtStructure: begin |
5313
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
556 |
gear^.Elasticity:= _0_55; |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
557 |
gear^.Friction:= _0_995; |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
558 |
gear^.Density:= _0_9; |
4881
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4867
diff
changeset
|
559 |
gear^.Radius:= 13; |
5313
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
560 |
gear^.Health:= 200; |
5013 | 561 |
gear^.Tag:= 3; |
4881
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4867
diff
changeset
|
562 |
end; |
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
563 |
end; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
564 |
|
2695 | 565 |
InsertGearToList(gear); |
566 |
AddGear:= gear; |
|
2786 | 567 |
|
2792 | 568 |
ScriptCall('onGearAdd', gear^.uid); |
4 | 569 |
end; |
570 |
||
1515 | 571 |
procedure DeleteGear(Gear: PGear); |
48 | 572 |
var team: PTeam; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
573 |
t,i: Longword; |
2760
420fe0344e5f
... or. just move the king check to after the gear nil
nemo
parents:
2759
diff
changeset
|
574 |
k: boolean; |
4 | 575 |
begin |
2786 | 576 |
|
2792 | 577 |
ScriptCall('onGearDelete', gear^.uid); |
2786 | 578 |
|
503 | 579 |
DeleteCI(Gear); |
762 | 580 |
|
581 |
if Gear^.Tex <> nil then |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
582 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
583 |
FreeTexture(Gear^.Tex); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
584 |
Gear^.Tex:= nil |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
585 |
end; |
762 | 586 |
|
3422
41ae3c48faa0
* some changes/cleanups to portal, still much to do :/ * reverted nemo's temporary loop fix * notice: small loops possible again, so take care :P, bigger onces should be interrupted
sheepluva
parents:
3415
diff
changeset
|
587 |
// make sure that portals have their link removed before deletion |
3428 | 588 |
if (Gear^.Kind = gtPortal) then |
3432
83cef0f08a86
* get rid of some fpc hints (redundant/superfluous includes)
sheepluva
parents:
3429
diff
changeset
|
589 |
begin |
3428 | 590 |
if (Gear^.IntersectGear <> nil) then |
3472
b1832a3761e6
portal-link-bugfix: make sure deleted portals don't reset links other than those to themselves
sheepluva
parents:
3471
diff
changeset
|
591 |
if (Gear^.IntersectGear^.IntersectGear = Gear) then |
b1832a3761e6
portal-link-bugfix: make sure deleted portals don't reset links other than those to themselves
sheepluva
parents:
3471
diff
changeset
|
592 |
Gear^.IntersectGear^.IntersectGear:= nil; |
3432
83cef0f08a86
* get rid of some fpc hints (redundant/superfluous includes)
sheepluva
parents:
3429
diff
changeset
|
593 |
end |
3422
41ae3c48faa0
* some changes/cleanups to portal, still much to do :/ * reverted nemo's temporary loop fix * notice: small loops possible again, so take care :P, bigger onces should be interrupted
sheepluva
parents:
3415
diff
changeset
|
594 |
else if Gear^.Kind = gtHedgehog then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
595 |
if (CurAmmoGear <> nil) and (CurrentHedgehog^.Gear = Gear) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
596 |
begin |
3894 | 597 |
Gear^.Message:= gmDestroy; |
598 |
CurAmmoGear^.Message:= gmDestroy; |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
599 |
exit |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
600 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
601 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
602 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
603 |
if (hwRound(Gear^.Y) >= cWaterLine) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
604 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
605 |
t:= max(Gear^.Damage, Gear^.Health); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
606 |
Gear^.Damage:= t; |
4792
68f9b331014a
sudden death changes: only change visual bit on health decrease and support for water transparancy change and clouds number change
Henek
parents:
4790
diff
changeset
|
607 |
if ((not SuddenDeathDmg and (cWaterOpacity < $FF)) or (SuddenDeathDmg and (cWaterOpacity < $FF))) and (hwRound(Gear^.Y) < cWaterLine + 256) then |
3461
0781275649e9
revert the restoration of non-vgt health gears. desyncs continued with it, and furthermore, occur in r3489 too
nemo
parents:
3460
diff
changeset
|
608 |
spawnHealthTagForHH(Gear, t); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
609 |
end; |
2376 | 610 |
|
4365 | 611 |
team:= Gear^.Hedgehog^.Team; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
612 |
if CurrentHedgehog^.Gear = Gear then |
5033 | 613 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
614 |
FreeActionsList; // to avoid ThinkThread on drawned gear |
5033 | 615 |
if ((Ammoz[CurrentHedgehog^.CurAmmoType].Ammo.Propz and ammoprop_NoRoundEnd) <> 0) and (CurrentHedgehog^.MultiShootAttacks > 0) then OnUsedAmmo(CurrentHedgehog^); |
616 |
end; |
|
2376 | 617 |
|
4365 | 618 |
Gear^.Hedgehog^.Gear:= nil; |
619 |
if Gear^.Hedgehog^.King then |
|
2758
033aa644578f
Add one king per team instead of clan, kill off clan if all kings are dead. untested.
nemo
parents:
2745
diff
changeset
|
620 |
begin |
033aa644578f
Add one king per team instead of clan, kill off clan if all kings are dead. untested.
nemo
parents:
2745
diff
changeset
|
621 |
// are there any other kings left? Just doing nil check. Presumably a mortally wounded king will get reaped soon enough |
2760
420fe0344e5f
... or. just move the king check to after the gear nil
nemo
parents:
2759
diff
changeset
|
622 |
k:= false; |
2726 | 623 |
for i:= 0 to Pred(team^.Clan^.TeamsNumber) do |
2760
420fe0344e5f
... or. just move the king check to after the gear nil
nemo
parents:
2759
diff
changeset
|
624 |
if (team^.Clan^.Teams[i]^.Hedgehogs[0].Gear <> nil) then k:= true; |
420fe0344e5f
... or. just move the king check to after the gear nil
nemo
parents:
2759
diff
changeset
|
625 |
if not k then |
2758
033aa644578f
Add one king per team instead of clan, kill off clan if all kings are dead. untested.
nemo
parents:
2745
diff
changeset
|
626 |
for i:= 0 to Pred(team^.Clan^.TeamsNumber) do |
4037 | 627 |
begin |
628 |
team^.Clan^.Teams[i]^.hasGone:= true; |
|
2758
033aa644578f
Add one king per team instead of clan, kill off clan if all kings are dead. untested.
nemo
parents:
2745
diff
changeset
|
629 |
TeamGoneEffect(team^.Clan^.Teams[i]^) |
4037 | 630 |
end |
2758
033aa644578f
Add one king per team instead of clan, kill off clan if all kings are dead. untested.
nemo
parents:
2745
diff
changeset
|
631 |
end; |
5202 | 632 |
|
633 |
// should be not CurrentHedgehog, but hedgehog of the last gear which caused damage to this hog |
|
634 |
// same stand for CheckHHDamage |
|
635 |
if (Gear^.LastDamage <> nil) then |
|
636 |
uStats.HedgehogDamaged(Gear, Gear^.LastDamage, 0, true) |
|
637 |
else |
|
638 |
uStats.HedgehogDamaged(Gear, CurrentHedgehog, 0, true); |
|
639 |
||
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
640 |
inc(KilledHHs); |
4455
a0c8779713f2
In AI survival mode, have the AI score when it kills humans, instead of its own team, clear poison on an AI kill, and reset AI health using InitialHealth instead of 100.
nemo
parents:
4443
diff
changeset
|
641 |
RecountTeamHealth(team); |
a0c8779713f2
In AI survival mode, have the AI score when it kills humans, instead of its own team, clear poison on an AI kill, and reset AI health using InitialHealth instead of 100.
nemo
parents:
4443
diff
changeset
|
642 |
if (CurrentHedgehog <> nil) and CurrentHedgehog^.Effects[heResurrectable] and not Gear^.Hedgehog^.Effects[heResurrectable] then |
a0c8779713f2
In AI survival mode, have the AI score when it kills humans, instead of its own team, clear poison on an AI kill, and reset AI health using InitialHealth instead of 100.
nemo
parents:
4443
diff
changeset
|
643 |
with CurrentHedgehog^ do |
a0c8779713f2
In AI survival mode, have the AI score when it kills humans, instead of its own team, clear poison on an AI kill, and reset AI health using InitialHealth instead of 100.
nemo
parents:
4443
diff
changeset
|
644 |
begin |
a0c8779713f2
In AI survival mode, have the AI score when it kills humans, instead of its own team, clear poison on an AI kill, and reset AI health using InitialHealth instead of 100.
nemo
parents:
4443
diff
changeset
|
645 |
inc(Team^.stats.AIKills); |
a0c8779713f2
In AI survival mode, have the AI score when it kills humans, instead of its own team, clear poison on an AI kill, and reset AI health using InitialHealth instead of 100.
nemo
parents:
4443
diff
changeset
|
646 |
if Team^.AIKillsTex <> nil then FreeTexture(Team^.AIKillsTex); |
a0c8779713f2
In AI survival mode, have the AI score when it kills humans, instead of its own team, clear poison on an AI kill, and reset AI health using InitialHealth instead of 100.
nemo
parents:
4443
diff
changeset
|
647 |
Team^.AIKillsTex := RenderStringTex(inttostr(Team^.stats.AIKills), Team^.Clan^.Color, fnt16); |
a0c8779713f2
In AI survival mode, have the AI score when it kills humans, instead of its own team, clear poison on an AI kill, and reset AI health using InitialHealth instead of 100.
nemo
parents:
4443
diff
changeset
|
648 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
649 |
end; |
4900 | 650 |
with Gear^ do |
651 |
AddFileLog('Delete: #' + inttostr(uid) + ' (' + inttostr(hwRound(x)) + ',' + inttostr(hwRound(y)) + '), d(' + floattostr(dX) + ',' + floattostr(dY) + ') type = ' + EnumToStr(Kind)); |
|
1495 | 652 |
|
82 | 653 |
if CurAmmoGear = Gear then CurAmmoGear:= nil; |
4 | 654 |
if FollowGear = Gear then FollowGear:= nil; |
4780
8571151411b3
add a couple of variables to speed up UID lookups. Based on the assumption new visual gears and gears will tend to be at the end of the list. Set them on successful lookup or script gear creation, clear on delete. Oh also pick up a couple of TrevInc's translation changes
nemo
parents:
4748
diff
changeset
|
655 |
if lastGearByUID = Gear then lastGearByUID := nil; |
294 | 656 |
RemoveGearFromList(Gear); |
1515 | 657 |
Dispose(Gear) |
4 | 658 |
end; |
659 |
||
660 |
function CheckNoDamage: boolean; // returns TRUE in case of no damaged hhs |
|
661 |
var Gear: PGear; |
|
1849 | 662 |
dmg: LongInt; |
4 | 663 |
begin |
351 | 664 |
CheckNoDamage:= true; |
4 | 665 |
Gear:= GearsList; |
666 |
while Gear <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
667 |
begin |
4120
0aba28eb8e34
more button updates, wait for hogs in infinite attack mode stop moving before clearing their damage (just used an arbitrary small interval)
nemo
parents:
4111
diff
changeset
|
668 |
if (Gear^.Kind = gtHedgehog) and (((GameFlags and gfInfAttack) = 0) or ((Gear^.dX.QWordValue < _0_000004.QWordValue) and (Gear^.dY.QWordValue < _0_000004.QWordValue))) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
669 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
670 |
if (not isInMultiShoot) then inc(Gear^.Damage, Gear^.Karma); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
671 |
if (Gear^.Damage <> 0) and |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
672 |
(not Gear^.Invulnerable) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
673 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
674 |
CheckNoDamage:= false; |
4824 | 675 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
676 |
dmg:= Gear^.Damage; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
677 |
if Gear^.Health < dmg then |
3453 | 678 |
begin |
679 |
Gear^.Active:= true; |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
680 |
Gear^.Health:= 0 |
3453 | 681 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
682 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
683 |
dec(Gear^.Health, dmg); |
351 | 684 |
|
4365 | 685 |
if (Gear^.Hedgehog^.Team = CurrentTeam) and |
2135
0b7972dfad01
Push karma application to end of round - should avoid problems w/ plane and kamikaze
nemo
parents:
2134
diff
changeset
|
686 |
(Gear^.Damage <> Gear^.Karma) and |
4365 | 687 |
not Gear^.Hedgehog^.King and |
688 |
not Gear^.Hedgehog^.Effects[hePoisoned] and |
|
2017 | 689 |
not SuddenDeathDmg then |
690 |
Gear^.State:= Gear^.State or gstLoser; |
|
691 |
||
3461
0781275649e9
revert the restoration of non-vgt health gears. desyncs continued with it, and furthermore, occur in r3489 too
nemo
parents:
3460
diff
changeset
|
692 |
spawnHealthTagForHH(Gear, dmg); |
867 | 693 |
|
4365 | 694 |
RenderHealth(Gear^.Hedgehog^); |
695 |
RecountTeamHealth(Gear^.Hedgehog^.Team); |
|
1505 | 696 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
697 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
698 |
if (not isInMultiShoot) then Gear^.Karma:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
699 |
Gear^.Damage:= 0 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
700 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
701 |
Gear:= Gear^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
702 |
end; |
4 | 703 |
end; |
704 |
||
1054 | 705 |
procedure HealthMachine; |
706 |
var Gear: PGear; |
|
2824
2d25e49bc2e8
Extra incentive to attack non-king hogs. If king loses his entourage, he loses 5hp per turn
nemo
parents:
2814
diff
changeset
|
707 |
team: PTeam; |
2d25e49bc2e8
Extra incentive to attack non-king hogs. If king loses his entourage, he loses 5hp per turn
nemo
parents:
2814
diff
changeset
|
708 |
i: LongWord; |
2d25e49bc2e8
Extra incentive to attack non-king hogs. If king loses his entourage, he loses 5hp per turn
nemo
parents:
2814
diff
changeset
|
709 |
flag: Boolean; |
3682 | 710 |
tmp: LongWord; |
1054 | 711 |
begin |
3682 | 712 |
Gear:= GearsList; |
1054 | 713 |
|
3682 | 714 |
while Gear <> nil do |
715 |
begin |
|
716 |
if Gear^.Kind = gtHedgehog then |
|
717 |
begin |
|
718 |
tmp:= 0; |
|
4365 | 719 |
if Gear^.Hedgehog^.Effects[hePoisoned] then |
4111 | 720 |
begin |
3908
1429c303858d
Can't use cHealthDecrease here for these two 'cause it isn't a generic "do some damage to hog" flag, but is rather set when SD starts
nemo
parents:
3894
diff
changeset
|
721 |
inc(tmp, ModifyDamage(5, Gear)); |
4365 | 722 |
if (GameFlags and gfResetHealth) <> 0 then dec(Gear^.Hedgehog^.InitialHealth) // does not need a minimum check since <= 1 basically disables it |
4111 | 723 |
end; |
4153
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
724 |
if (TotalRounds > cSuddenDTurns - 1) then |
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
725 |
begin |
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
726 |
inc(tmp, cHealthDecrease); |
4365 | 727 |
if (GameFlags and gfResetHealth) <> 0 then dec(Gear^.Hedgehog^.InitialHealth, cHealthDecrease) |
4153
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
728 |
end; |
4365 | 729 |
if Gear^.Hedgehog^.King then |
3109
06c089cb739c
Reduce turns to -1 to allow processing health machine on first turn. Needs testing with Sudden Death set to 0
nemo
parents:
3107
diff
changeset
|
730 |
begin |
06c089cb739c
Reduce turns to -1 to allow processing health machine on first turn. Needs testing with Sudden Death set to 0
nemo
parents:
3107
diff
changeset
|
731 |
flag:= false; |
4365 | 732 |
team:= Gear^.Hedgehog^.Team; |
3109
06c089cb739c
Reduce turns to -1 to allow processing health machine on first turn. Needs testing with Sudden Death set to 0
nemo
parents:
3107
diff
changeset
|
733 |
for i:= 0 to Pred(team^.HedgehogsNumber) do |
3697 | 734 |
if (team^.Hedgehogs[i].Gear <> nil) and |
735 |
(not team^.Hedgehogs[i].King) and |
|
736 |
(team^.Hedgehogs[i].Gear^.Health > team^.Hedgehogs[i].Gear^.Damage) |
|
3109
06c089cb739c
Reduce turns to -1 to allow processing health machine on first turn. Needs testing with Sudden Death set to 0
nemo
parents:
3107
diff
changeset
|
737 |
then flag:= true; |
4111 | 738 |
if not flag then |
739 |
begin |
|
740 |
inc(tmp, 5); |
|
4365 | 741 |
if (GameFlags and gfResetHealth) <> 0 then dec(Gear^.Hedgehog^.InitialHealth, 5) |
4111 | 742 |
end |
3109
06c089cb739c
Reduce turns to -1 to allow processing health machine on first turn. Needs testing with Sudden Death set to 0
nemo
parents:
3107
diff
changeset
|
743 |
end; |
3845
90034acb2e43
Untested fix of r3672 - should avoid hogs dying due to multiple health machine sources, and inappropriate application of karma/vampirism to these.
nemo
parents:
3836
diff
changeset
|
744 |
if tmp > 0 then |
90034acb2e43
Untested fix of r3672 - should avoid hogs dying due to multiple health machine sources, and inappropriate application of karma/vampirism to these.
nemo
parents:
3836
diff
changeset
|
745 |
begin |
90034acb2e43
Untested fix of r3672 - should avoid hogs dying due to multiple health machine sources, and inappropriate application of karma/vampirism to these.
nemo
parents:
3836
diff
changeset
|
746 |
inc(Gear^.Damage, min(tmp, max(0,Gear^.Health - 1 - Gear^.Damage))); |
90034acb2e43
Untested fix of r3672 - should avoid hogs dying due to multiple health machine sources, and inappropriate application of karma/vampirism to these.
nemo
parents:
3836
diff
changeset
|
747 |
HHHurt(Gear^.Hedgehog, dsPoison); |
90034acb2e43
Untested fix of r3672 - should avoid hogs dying due to multiple health machine sources, and inappropriate application of karma/vampirism to these.
nemo
parents:
3836
diff
changeset
|
748 |
end |
3682 | 749 |
end; |
1054 | 750 |
|
3682 | 751 |
Gear:= Gear^.NextGear |
752 |
end; |
|
1054 | 753 |
end; |
754 |
||
4 | 755 |
procedure ProcessGears; |
614 | 756 |
const delay: LongWord = 0; |
3949
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
757 |
delay2: LongWord = 0; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
758 |
step: (stDelay, stChDmg, stSweep, stTurnReact, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
759 |
stAfterDelay, stChWin, stWater, stChWin2, stHealth, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
760 |
stSpawn, stNTurn) = stDelay; |
4 | 761 |
var Gear, t: PGear; |
4207
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
762 |
i, AliveCount: LongInt; |
3331 | 763 |
s: shortstring; |
4 | 764 |
begin |
868 | 765 |
PrvInactive:= AllInactive; |
4 | 766 |
AllInactive:= true; |
1495 | 767 |
|
2940 | 768 |
if (StepSoundTimer > 0) and (StepSoundChannel < 0) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
769 |
StepSoundChannel:= LoopSound(sndSteps) |
2940 | 770 |
else if (StepSoundTimer = 0) and (StepSoundChannel > -1) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
771 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
772 |
StopSound(StepSoundChannel); |
2993
d83edb74e92d
Remove animation on jumping/resuming walk, only leave it in on weapon switch
nemo
parents:
2991
diff
changeset
|
773 |
StepSoundChannel:= -1 |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
774 |
end; |
2940 | 775 |
|
776 |
if StepSoundTimer > 0 then |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
777 |
dec(StepSoundTimer, 1); |
2940 | 778 |
|
4 | 779 |
t:= GearsList; |
1054 | 780 |
while t <> nil do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
781 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
782 |
Gear:= t; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
783 |
t:= Gear^.NextGear; |
3123 | 784 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
785 |
if Gear^.Active then |
2204
526f8165acce
Smaxx' idea of timers, reworked just a tad. Might need variable for offset, but seems ok for now
nemo
parents:
2186
diff
changeset
|
786 |
begin |
526f8165acce
Smaxx' idea of timers, reworked just a tad. Might need variable for offset, but seems ok for now
nemo
parents:
2186
diff
changeset
|
787 |
if Gear^.RenderTimer and (Gear^.Timer > 500) and ((Gear^.Timer mod 1000) = 0) then |
526f8165acce
Smaxx' idea of timers, reworked just a tad. Might need variable for offset, but seems ok for now
nemo
parents:
2186
diff
changeset
|
788 |
begin |
2376 | 789 |
if Gear^.Tex <> nil then FreeTexture(Gear^.Tex); |
2619 | 790 |
Gear^.Tex:= RenderStringTex(inttostr(Gear^.Timer div 1000), cWhiteColor, fntSmall); |
2204
526f8165acce
Smaxx' idea of timers, reworked just a tad. Might need variable for offset, but seems ok for now
nemo
parents:
2186
diff
changeset
|
791 |
end; |
526f8165acce
Smaxx' idea of timers, reworked just a tad. Might need variable for offset, but seems ok for now
nemo
parents:
2186
diff
changeset
|
792 |
Gear^.doStep(Gear); |
3848 | 793 |
// might be useful later |
4492 | 794 |
//ScriptCall('onGearStep', Gear^.uid); |
2204
526f8165acce
Smaxx' idea of timers, reworked just a tad. Might need variable for offset, but seems ok for now
nemo
parents:
2186
diff
changeset
|
795 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
796 |
end; |
89 | 797 |
|
4 | 798 |
if AllInactive then |
1343 | 799 |
case step of |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
800 |
stDelay: begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
801 |
if delay = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
802 |
delay:= cInactDelay |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
803 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
804 |
dec(delay); |
614 | 805 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
806 |
if delay = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
807 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
808 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
809 |
stChDmg: if CheckNoDamage then inc(step) else step:= stDelay; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
810 |
stSweep: if SweepDirty then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
811 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
812 |
SetAllToActive; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
813 |
step:= stChDmg |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
814 |
end else inc(step); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
815 |
stTurnReact: begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
816 |
if (not bBetweenTurns) and (not isInMultiShoot) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
817 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
818 |
uStats.TurnReaction; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
819 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
820 |
end else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
821 |
inc(step, 2); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
822 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
823 |
stAfterDelay: begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
824 |
if delay = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
825 |
delay:= cInactDelay |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
826 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
827 |
dec(delay); |
815 | 828 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
829 |
if delay = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
830 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
831 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
832 |
stChWin: begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
833 |
CheckForWin; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
834 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
835 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
836 |
stWater: if (not bBetweenTurns) and (not isInMultiShoot) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
837 |
begin |
3331 | 838 |
if TotalRounds = cSuddenDTurns + 1 then bWaterRising:= true; |
1055
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset
|
839 |
|
4153
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
840 |
if bWaterRising and (cWaterRise > 0) then |
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
841 |
AddGear(0, 0, gtWaterUp, 0, _0, _0, 0)^.Tag:= cWaterRise; |
1055
9af540b23409
Water rises after 25 mins of round, health is decreased after 20 mins
unc0rr
parents:
1054
diff
changeset
|
842 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
843 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
844 |
end else inc(step); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
845 |
stChWin2: begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
846 |
CheckForWin; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
847 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
848 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
849 |
stHealth: begin |
4215
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
850 |
if (cWaterRise <> 0) or (cHealthDecrease <> 0) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
851 |
begin |
4792
68f9b331014a
sudden death changes: only change visual bit on health decrease and support for water transparancy change and clouds number change
Henek
parents:
4790
diff
changeset
|
852 |
if (TotalRounds = cSuddenDTurns) and not SuddenDeath and not isInMultiShoot then |
4215
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
853 |
begin |
4792
68f9b331014a
sudden death changes: only change visual bit on health decrease and support for water transparancy change and clouds number change
Henek
parents:
4790
diff
changeset
|
854 |
SuddenDeath:= true; |
68f9b331014a
sudden death changes: only change visual bit on health decrease and support for water transparancy change and clouds number change
Henek
parents:
4790
diff
changeset
|
855 |
if cHealthDecrease <> 0 then |
68f9b331014a
sudden death changes: only change visual bit on health decrease and support for water transparancy change and clouds number change
Henek
parents:
4790
diff
changeset
|
856 |
begin |
68f9b331014a
sudden death changes: only change visual bit on health decrease and support for water transparancy change and clouds number change
Henek
parents:
4790
diff
changeset
|
857 |
SuddenDeathDmg:= true; |
5558
49cfd05ccb83
new SD flakes from mikade and a flash when sudden death starts
Henek
parents:
5556
diff
changeset
|
858 |
|
49cfd05ccb83
new SD flakes from mikade and a flash when sudden death starts
Henek
parents:
5556
diff
changeset
|
859 |
// flash |
49cfd05ccb83
new SD flakes from mikade and a flash when sudden death starts
Henek
parents:
5556
diff
changeset
|
860 |
ScreenFade:= sfFromWhite; |
49cfd05ccb83
new SD flakes from mikade and a flash when sudden death starts
Henek
parents:
5556
diff
changeset
|
861 |
ScreenFadeValue:= sfMax; |
49cfd05ccb83
new SD flakes from mikade and a flash when sudden death starts
Henek
parents:
5556
diff
changeset
|
862 |
ScreenFadeSpeed:= 1; |
49cfd05ccb83
new SD flakes from mikade and a flash when sudden death starts
Henek
parents:
5556
diff
changeset
|
863 |
|
4806
48c1a395f0a7
added flake configuration also in sudden death and SDClouds for underwater
Henek
parents:
4792
diff
changeset
|
864 |
ChangeToSDClouds; |
48c1a395f0a7
added flake configuration also in sudden death and SDClouds for underwater
Henek
parents:
4792
diff
changeset
|
865 |
ChangeToSDFlakes; |
4835
a6924450e694
added rq-sky to themes so it can set sky color for low quality. also added tint of sky on sudden death. underwater theme is an example of this
Henek
parents:
4834
diff
changeset
|
866 |
glClearColor(SDSkyColor.r / 255, SDSkyColor.g / 255, SDSkyColor.b / 255, 0.99); |
4792
68f9b331014a
sudden death changes: only change visual bit on health decrease and support for water transparancy change and clouds number change
Henek
parents:
4790
diff
changeset
|
867 |
end; |
4215
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
868 |
AddCaption(trmsg[sidSuddenDeath], cWhiteColor, capgrpGameState); |
4748 | 869 |
playSound(sndSuddenDeath); |
870 |
MusicFN:= SDMusic; |
|
871 |
ChangeMusic |
|
4215
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
872 |
end |
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
873 |
else if (TotalRounds < cSuddenDTurns) and not isInMultiShoot then |
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
874 |
begin |
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
875 |
i:= cSuddenDTurns - TotalRounds; |
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
876 |
s:= inttostr(i); |
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
877 |
if i = 1 then |
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
878 |
AddCaption(trmsg[sidRoundSD], cWhiteColor, capgrpGameState) |
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
879 |
else if i in [2, 5, 10, 15, 20, 25, 50, 100] then |
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
880 |
AddCaption(Format(trmsg[sidRoundsSD], s), cWhiteColor, capgrpGameState); |
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
881 |
end; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
882 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
883 |
if bBetweenTurns |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
884 |
or isInMultiShoot |
3109
06c089cb739c
Reduce turns to -1 to allow processing health machine on first turn. Needs testing with Sudden Death set to 0
nemo
parents:
3107
diff
changeset
|
885 |
or (TotalRounds = -1) then inc(step) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
886 |
else begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
887 |
bBetweenTurns:= true; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
888 |
HealthMachine; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
889 |
step:= stChDmg |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
890 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
891 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
892 |
stSpawn: begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
893 |
if not isInMultiShoot then SpawnBoxOfSmth; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
894 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
895 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
896 |
stNTurn: begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
897 |
if isInMultiShoot then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
898 |
isInMultiShoot:= false |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
899 |
else begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
900 |
// delayed till after 0.9.12 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
901 |
// reset to default zoom |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
902 |
//ZoomValue:= ZoomDefault; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
903 |
with CurrentHedgehog^ do |
3697 | 904 |
if (Gear <> nil) |
2611 | 905 |
and ((Gear^.State and gstAttacked) = 0) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
906 |
and (MultiShootAttacks > 0) then OnUsedAmmo(CurrentHedgehog^); |
3697 | 907 |
|
3396
e5b3e5f2818e
More portal changes. Allows for a multishoot utility. Hopefully not breaking anything.
nemo
parents:
3390
diff
changeset
|
908 |
EndTurnCleanup; |
2376 | 909 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
910 |
FreeActionsList; // could send -left, -right and similar commands, so should be called before /nextturn |
1298 | 911 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
912 |
ParseCommand('/nextturn', true); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
913 |
SwitchHedgehog; |
1298 | 914 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
915 |
AfterSwitchHedgehog; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
916 |
bBetweenTurns:= false |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
917 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
918 |
step:= Low(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
919 |
end; |
3949
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
920 |
end |
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
921 |
else if ((GameFlags and gfInfAttack) <> 0) then |
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
922 |
begin |
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
923 |
if delay2 = 0 then |
5296
0bb518ad2da8
At mikade's request and w/ unc0rr's blessing, dramatically slash inactivity delay from 1.25s down to a tenth of a second.
nemo
parents:
5284
diff
changeset
|
924 |
delay2:= cInactDelay * 50 |
3949
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
925 |
else |
3957 | 926 |
begin |
3949
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
927 |
dec(delay2); |
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
928 |
|
5509 | 929 |
if ((delay2 mod cInactDelay) = 0) and (CurrentHedgehog <> nil) and (CurrentHedgehog^.Gear <> nil) and not CurrentHedgehog^.Unplaced then |
5507
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5501
diff
changeset
|
930 |
begin |
5513
79dd457193e6
make a special case for teleport instead. also allows teleporting off of a parachute
nemo
parents:
5511
diff
changeset
|
931 |
if (CurrentHedgehog^.Gear^.State and gstAttacked <> 0) and (Ammoz[CurrentHedgehog^.CurAmmoType].Ammo.Propz and ammoprop_NeedTarget <> 0) then |
5507
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5501
diff
changeset
|
932 |
begin |
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5501
diff
changeset
|
933 |
CurrentHedgehog^.Gear^.State:= CurrentHedgehog^.Gear^.State or gstHHChooseTarget; |
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5501
diff
changeset
|
934 |
isCursorVisible := true |
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5501
diff
changeset
|
935 |
end; |
3957 | 936 |
CurrentHedgehog^.Gear^.State:= CurrentHedgehog^.Gear^.State and not gstAttacked; |
5507
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5501
diff
changeset
|
937 |
end; |
3957 | 938 |
if delay2 = 0 then |
939 |
begin |
|
5482 | 940 |
if (CurrentHedgehog^.Gear <> nil) and (CurrentHedgehog^.Gear^.State and gstAttacked = 0) then SweepDirty; |
3957 | 941 |
CheckNoDamage; |
4207
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
942 |
AliveCount:= 0; // shorter version of check for win to allow typical step activity to proceed |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
943 |
for i:= 0 to Pred(ClansCount) do |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
944 |
if ClansArray[i]^.ClanHealth > 0 then inc(AliveCount); |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
945 |
if (AliveCount <= 1) and ((GameFlags and gfOneClanMode) = 0) then |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
946 |
begin |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
947 |
step:= stChDmg; |
5016
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
5015
diff
changeset
|
948 |
if TagTurnTimeLeft = 0 then TagTurnTimeLeft:= TurnTimeLeft; |
4207
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
949 |
TurnTimeLeft:= 0 |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
950 |
end |
3957 | 951 |
end |
3949
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
952 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
953 |
end; |
15 | 954 |
|
4 | 955 |
if TurnTimeLeft > 0 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
956 |
if CurrentHedgehog^.Gear <> nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
957 |
if ((CurrentHedgehog^.Gear^.State and gstAttacking) = 0) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
958 |
and not isInMultiShoot then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
959 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
960 |
if (TurnTimeLeft = 5000) |
4198 | 961 |
and (cHedgehogTurnTime >= 10000) |
2770
851313907bcb
Decrease king buff from 150% bonus to 50% bonus, disable warning sound in placement mode
nemo
parents:
2762
diff
changeset
|
962 |
and (not PlacingHogs) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
963 |
and (CurrentHedgehog^.Gear <> nil) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
964 |
and ((CurrentHedgehog^.Gear^.State and gstAttacked) = 0) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
965 |
PlaySound(sndHurry, CurrentTeam^.voicepack); |
3799 | 966 |
if ReadyTimeLeft > 0 then |
967 |
begin |
|
968 |
if ReadyTimeLeft = 2000 then |
|
969 |
PlaySound(sndComeonthen, CurrentTeam^.voicepack); |
|
970 |
dec(ReadyTimeLeft) |
|
971 |
end |
|
972 |
else |
|
973 |
dec(TurnTimeLeft) |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
974 |
end; |
351 | 975 |
|
2621
956ff066f3a5
Fix desync when playing with AI via network, occuring in certain conditions
unc0rr
parents:
2619
diff
changeset
|
976 |
if skipFlag then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
977 |
begin |
5016
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
5015
diff
changeset
|
978 |
if TagTurnTimeLeft = 0 then TagTurnTimeLeft:= TurnTimeLeft; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
979 |
TurnTimeLeft:= 0; |
3784
75aa91bea32b
Extend statistics collection (TeamKills, TurnSkips, TeamDamage)
burp
parents:
3775
diff
changeset
|
980 |
skipFlag:= false; |
75aa91bea32b
Extend statistics collection (TeamKills, TurnSkips, TeamDamage)
burp
parents:
3775
diff
changeset
|
981 |
inc(CurrentHedgehog^.Team^.stats.TurnSkips); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
982 |
end; |
2621
956ff066f3a5
Fix desync when playing with AI via network, occuring in certain conditions
unc0rr
parents:
2619
diff
changeset
|
983 |
|
2134 | 984 |
if ((GameTicks and $FFFF) = $FFFF) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
985 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
986 |
if (not CurrentTeam^.ExtDriven) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
987 |
SendIPCTimeInc; |
2134 | 988 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
989 |
if (not CurrentTeam^.ExtDriven) or CurrentTeam^.hasGone then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
990 |
inc(hiTicks) // we do not recieve a message for this |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
991 |
end; |
656
6d6d9d7b1054
Fix network game bug caused by recent protocol changes
unc0rr
parents:
651
diff
changeset
|
992 |
|
4417
6bf00d99fc47
move this call to where the game tick is actually incremented
nemo
parents:
4406
diff
changeset
|
993 |
ScriptCall('onGameTick'); |
515 | 994 |
inc(GameTicks) |
4 | 995 |
end; |
996 |
||
3396
e5b3e5f2818e
More portal changes. Allows for a multishoot utility. Hopefully not breaking anything.
nemo
parents:
3390
diff
changeset
|
997 |
//Purpose, to reset all transient attributes toggled by a utility and clean up various gears and effects at end of turn |
1854 | 998 |
//If any of these are set as permanent toggles in the frontend, that needs to be checked and skipped here. |
3396
e5b3e5f2818e
More portal changes. Allows for a multishoot utility. Hopefully not breaking anything.
nemo
parents:
3390
diff
changeset
|
999 |
procedure EndTurnCleanup; |
1865
ebc6dfca60d4
- nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1863
diff
changeset
|
1000 |
var i: LongInt; |
3480
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
1001 |
t: PGear; |
1849 | 1002 |
begin |
2221 | 1003 |
SpeechText:= ''; // in case it has not been consumed |
2017 | 1004 |
|
1895 | 1005 |
if (GameFlags and gfLowGravity) = 0 then |
4623 | 1006 |
begin |
3355
dc9e61e67484
cWindSpeed recalculation assumed GetRandom returns a value between 0.0-1.0 while in fact is in the 0.0-0.5 range; Halve cMaxWindSpeed to compensate.
palewolf
parents:
3350
diff
changeset
|
1007 |
cGravity:= cMaxWindSpeed * 2; |
4623 | 1008 |
cGravityf:= 0.00025 * 2 |
1009 |
end; |
|
1895 | 1010 |
|
2017 | 1011 |
if (GameFlags and gfVampiric) = 0 then |
1012 |
cVampiric:= false; |
|
1013 |
||
1849 | 1014 |
cDamageModifier:= _1; |
1895 | 1015 |
|
1016 |
if (GameFlags and gfLaserSight) = 0 then |
|
1017 |
cLaserSighting:= false; |
|
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
1018 |
|
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
1019 |
if (GameFlags and gfArtillery) = 0 then |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
1020 |
cArtillery:= false; |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
1021 |
// have to sweep *all* current team hedgehogs since it is theoretically possible if you have enough invulnerabilities and switch turns to make your entire team invulnerable |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
1022 |
if (CurrentTeam <> nil) then |
4099 | 1023 |
with CurrentTeam^ do |
1024 |
for i:= 0 to cMaxHHIndex do |
|
1025 |
with Hedgehogs[i] do |
|
1026 |
begin |
|
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1027 |
(* |
4099 | 1028 |
if (SpeechGear <> nil) then |
1029 |
begin |
|
1030 |
DeleteVisualGear(SpeechGear); // remove to restore persisting beyond end of turn. Tiy says was too much of a gameplay issue |
|
1031 |
SpeechGear:= nil |
|
1032 |
end; |
|
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1033 |
*) |
2045
b0588498bc3a
- Fix network (my crappy fault, triggered by nemo's patch)
unc0rr
parents:
2042
diff
changeset
|
1034 |
|
4099 | 1035 |
if (Gear <> nil) then |
1036 |
begin |
|
1037 |
if (GameFlags and gfInvulnerable) = 0 then |
|
1038 |
Gear^.Invulnerable:= false; |
|
1039 |
end; |
|
1040 |
end; |
|
3480
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
1041 |
t:= GearsList; |
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
1042 |
while t <> nil do |
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
1043 |
begin |
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
1044 |
t^.PortalCounter:= 0; |
4372 | 1045 |
if ((GameFlags and gfResetHealth) <> 0) and (t^.Kind = gtHedgehog) and (t^.Health < t^.Hedgehog^.InitialHealth) then |
4101
c5967f360beb
Apply the reset to all hogs on all teams in uGears. Make InitialHealth same type as Health to avoid issues w/ initial health > 255. Update InitialHealth with the king buff.
nemo
parents:
4099
diff
changeset
|
1046 |
begin |
4372 | 1047 |
t^.Health:= t^.Hedgehog^.InitialHealth; |
1048 |
RenderHealth(t^.Hedgehog^); |
|
4101
c5967f360beb
Apply the reset to all hogs on all teams in uGears. Make InitialHealth same type as Health to avoid issues w/ initial health > 255. Update InitialHealth with the king buff.
nemo
parents:
4099
diff
changeset
|
1049 |
end; |
3480
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
1050 |
t:= t^.NextGear |
3946
41e06b74c991
Enable resetting of weapons after each turn - useful in combination with a limited weaponset and unlimited attacks
nemo
parents:
3908
diff
changeset
|
1051 |
end; |
41e06b74c991
Enable resetting of weapons after each turn - useful in combination with a limited weaponset and unlimited attacks
nemo
parents:
3908
diff
changeset
|
1052 |
|
4344
23ab3bdbf218
This should fix Chip's bug with unlimited teleports. Also remove more hog placement special behaviour and just use ResetWeapons with a check against PlacingHogs mode
nemo
parents:
4337
diff
changeset
|
1053 |
if ((GameFlags and gfResetWeps) <> 0) and not PlacingHogs then |
4099 | 1054 |
ResetWeapons; |
4101
c5967f360beb
Apply the reset to all hogs on all teams in uGears. Make InitialHealth same type as Health to avoid issues w/ initial health > 255. Update InitialHealth with the king buff.
nemo
parents:
4099
diff
changeset
|
1055 |
|
4099 | 1056 |
if (GameFlags and gfResetHealth) <> 0 then |
4101
c5967f360beb
Apply the reset to all hogs on all teams in uGears. Make InitialHealth same type as Health to avoid issues w/ initial health > 255. Update InitialHealth with the king buff.
nemo
parents:
4099
diff
changeset
|
1057 |
for i:= 0 to Pred(TeamsCount) do |
c5967f360beb
Apply the reset to all hogs on all teams in uGears. Make InitialHealth same type as Health to avoid issues w/ initial health > 255. Update InitialHealth with the king buff.
nemo
parents:
4099
diff
changeset
|
1058 |
RecountTeamHealth(TeamsArray[i]) |
1849 | 1059 |
end; |
2045
b0588498bc3a
- Fix network (my crappy fault, triggered by nemo's patch)
unc0rr
parents:
2042
diff
changeset
|
1060 |
|
4837
2ea0a152c319
Pass PHedgehog instead of PGear to stats. Fixes crash.
unc0rr
parents:
4835
diff
changeset
|
1061 |
procedure ApplyDamage(Gear: PGear; AttackerHog: PHedgehog; Damage: Longword; Source: TDamageSource); |
2017 | 1062 |
var s: shortstring; |
2428 | 1063 |
vampDmg, tmpDmg, i: Longword; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1064 |
vg: PVisualGear; |
2017 | 1065 |
begin |
4885 | 1066 |
if Damage = 0 then exit; // nothing to apply |
1067 |
||
1068 |
if (Gear^.Kind = gtHedgehog) then |
|
2017 | 1069 |
begin |
5062 | 1070 |
Gear^.LastDamage := AttackerHog; |
1071 |
||
4978 | 1072 |
Gear^.Hedgehog^.Team^.Clan^.Flawless:= false; |
3682 | 1073 |
HHHurt(Gear^.Hedgehog, Source); |
4365 | 1074 |
AddDamageTag(hwRound(Gear^.X), hwRound(Gear^.Y), Damage, Gear^.Hedgehog^.Team^.Clan^.Color); |
2067
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1075 |
tmpDmg:= min(Damage, max(0,Gear^.Health-Gear^.Damage)); |
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1076 |
if (Gear <> CurrentHedgehog^.Gear) and (CurrentHedgehog^.Gear <> nil) and (tmpDmg >= 1) then |
2017 | 1077 |
begin |
1078 |
if cVampiric then |
|
1079 |
begin |
|
2067
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1080 |
vampDmg:= hwRound(int2hwFloat(tmpDmg)*_0_8); |
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1081 |
if vampDmg >= 1 then |
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1082 |
begin |
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1083 |
// was considering pulsing on attack, Tiy thinks it should be permanent while in play |
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1084 |
//CurrentHedgehog^.Gear^.State:= CurrentHedgehog^.Gear^.State or gstVampiric; |
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1085 |
inc(CurrentHedgehog^.Gear^.Health,vampDmg); |
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1086 |
str(vampDmg, s); |
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1087 |
s:= '+' + s; |
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1088 |
AddCaption(s, CurrentHedgehog^.Team^.Clan^.Color, capgrpAmmoinfo); |
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1089 |
RenderHealth(CurrentHedgehog^); |
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1090 |
RecountTeamHealth(CurrentHedgehog^.Team); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1091 |
i:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1092 |
while i < vampDmg do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1093 |
begin |
5563 | 1094 |
vg:= AddVisualGear(hwRound(CurrentHedgehog^.Gear^.X), hwRound(CurrentHedgehog^.Gear^.Y), vgtStraightShot); |
1095 |
if vg <> nil then |
|
1096 |
with vg^ do |
|
1097 |
begin |
|
1098 |
Tint:= $FF0000FF; |
|
5564
4f42009237df
For mikade's sake, use old dx/dy/frametick as default, so health crosses move the same
nemo
parents:
5563
diff
changeset
|
1099 |
State:= ord(sprHealth) |
5563 | 1100 |
end; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1101 |
inc(i, 5); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1102 |
end; |
2067
7524a783bd8c
use separate variable for vamp/karma calcs, move karma damage tag from point of damage origin to originating hedgehog at unc0rr's request
nemo
parents:
2057
diff
changeset
|
1103 |
end |
2017 | 1104 |
end; |
2376 | 1105 |
if ((GameFlags and gfKarma) <> 0) and |
2017 | 1106 |
((GameFlags and gfInvulnerable) = 0) and |
1107 |
not CurrentHedgehog^.Gear^.Invulnerable then |
|
1108 |
begin // this cannot just use Damage or it interrupts shotgun and gets you called stupid |
|
2135
0b7972dfad01
Push karma application to end of round - should avoid problems w/ plane and kamikaze
nemo
parents:
2134
diff
changeset
|
1109 |
inc(CurrentHedgehog^.Gear^.Karma, tmpDmg); |
5062 | 1110 |
CurrentHedgehog^.Gear^.LastDamage := CurrentHedgehog; |
3461
0781275649e9
revert the restoration of non-vgt health gears. desyncs continued with it, and furthermore, occur in r3489 too
nemo
parents:
3460
diff
changeset
|
1111 |
spawnHealthTagForHH(CurrentHedgehog^.Gear, tmpDmg); |
2017 | 1112 |
end; |
5202 | 1113 |
uStats.HedgehogDamaged(Gear, AttackerHog, Damage, false); |
2017 | 1114 |
end; |
4881
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4867
diff
changeset
|
1115 |
end else if Gear^.Kind <> gtStructure then // not gtHedgehog nor gtStructure |
4837
2ea0a152c319
Pass PHedgehog instead of PGear to stats. Fixes crash.
unc0rr
parents:
4835
diff
changeset
|
1116 |
begin |
2ea0a152c319
Pass PHedgehog instead of PGear to stats. Fixes crash.
unc0rr
parents:
4835
diff
changeset
|
1117 |
Gear^.Hedgehog:= AttackerHog; |
2ea0a152c319
Pass PHedgehog instead of PGear to stats. Fixes crash.
unc0rr
parents:
4835
diff
changeset
|
1118 |
end; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1119 |
inc(Gear^.Damage, Damage); |
5190 | 1120 |
|
4492 | 1121 |
ScriptCall('onGearDamage', Gear^.UID, Damage); |
2017 | 1122 |
end; |
1849 | 1123 |
|
4 | 1124 |
procedure SetAllToActive; |
1125 |
var t: PGear; |
|
1126 |
begin |
|
1127 |
AllInactive:= false; |
|
1128 |
t:= GearsList; |
|
351 | 1129 |
while t <> nil do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1130 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1131 |
t^.Active:= true; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1132 |
t:= t^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1133 |
end |
4 | 1134 |
end; |
1135 |
||
1136 |
procedure SetAllHHToActive; |
|
1137 |
var t: PGear; |
|
1138 |
begin |
|
1139 |
AllInactive:= false; |
|
1140 |
t:= GearsList; |
|
351 | 1141 |
while t <> nil do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1142 |
begin |
4813
53c2f0f92281
Make barrels drop when hog walks away from under it
unc0rr
parents:
4809
diff
changeset
|
1143 |
if (t^.Kind = gtHedgehog) or (t^.Kind = gtExplosives) then t^.Active:= true; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1144 |
t:= t^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1145 |
end |
4 | 1146 |
end; |
1147 |
||
4385 | 1148 |
|
1149 |
procedure DrawGears; |
|
1150 |
var Gear: PGear; |
|
1151 |
x, y: LongInt; |
|
2802 | 1152 |
begin |
4385 | 1153 |
Gear:= GearsList; |
1154 |
while Gear <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1155 |
begin |
5348
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset
|
1156 |
if Gear^.State and gstInvisible = 0 then |
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset
|
1157 |
begin |
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset
|
1158 |
x:= hwRound(Gear^.X) + WorldDx; |
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset
|
1159 |
y:= hwRound(Gear^.Y) + WorldDy; |
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset
|
1160 |
RenderGear(Gear, x, y); |
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset
|
1161 |
end; |
4385 | 1162 |
Gear:= Gear^.NextGear |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1163 |
end; |
2802 | 1164 |
end; |
1165 |
||
4 | 1166 |
procedure FreeGearsList; |
1167 |
var t, tt: PGear; |
|
1168 |
begin |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1169 |
tt:= GearsList; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1170 |
GearsList:= nil; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1171 |
while tt <> nil do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1172 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1173 |
t:= tt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1174 |
tt:= tt^.NextGear; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1175 |
Dispose(t) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1176 |
end; |
4 | 1177 |
end; |
1178 |
||
10 | 1179 |
procedure AddMiscGears; |
5179
8d64dcb566ea
Fix "Mixing signed expressions and longwords gives a 64bit result" warnings
unc0rr
parents:
5139
diff
changeset
|
1180 |
var i: Longword; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1181 |
Gear: PGear; |
4 | 1182 |
begin |
498 | 1183 |
AddGear(0, 0, gtATStartGame, 0, _0, _0, 2000); |
1435
d4b32ee3caa6
Fix using freed memory (could be the cause of queue error problem and other bugs)
unc0rr
parents:
1434
diff
changeset
|
1184 |
|
4830
c5ddc3e6c8a4
Don't waste CPU cycles trying to find a piece of land when there's no free land left
unc0rr
parents:
4826
diff
changeset
|
1185 |
i:= 0; |
c5ddc3e6c8a4
Don't waste CPU cycles trying to find a piece of land when there's no free land left
unc0rr
parents:
4826
diff
changeset
|
1186 |
Gear:= PGear(1); |
4834 | 1187 |
while (i < cLandMines) {and (Gear <> nil)} do // disable this check until better solution found |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1188 |
begin |
4148
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
1189 |
Gear:= AddGear(0, 0, gtMine, 0, _0, _0, 0); |
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
1190 |
FindPlace(Gear, false, 0, LAND_WIDTH); |
4830
c5ddc3e6c8a4
Don't waste CPU cycles trying to find a piece of land when there's no free land left
unc0rr
parents:
4826
diff
changeset
|
1191 |
inc(i) |
4148
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
1192 |
end; |
4830
c5ddc3e6c8a4
Don't waste CPU cycles trying to find a piece of land when there's no free land left
unc0rr
parents:
4826
diff
changeset
|
1193 |
|
c5ddc3e6c8a4
Don't waste CPU cycles trying to find a piece of land when there's no free land left
unc0rr
parents:
4826
diff
changeset
|
1194 |
i:= 0; |
c5ddc3e6c8a4
Don't waste CPU cycles trying to find a piece of land when there's no free land left
unc0rr
parents:
4826
diff
changeset
|
1195 |
Gear:= PGear(1); |
4833 | 1196 |
while (i < cExplosives){ and (Gear <> nil)} do |
4148
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
1197 |
begin |
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
1198 |
Gear:= AddGear(0, 0, gtExplosives, 0, _0, _0, 0); |
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
1199 |
FindPlace(Gear, false, 0, LAND_WIDTH); |
4830
c5ddc3e6c8a4
Don't waste CPU cycles trying to find a piece of land when there's no free land left
unc0rr
parents:
4826
diff
changeset
|
1200 |
inc(i) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1201 |
end; |
1895 | 1202 |
|
1203 |
if (GameFlags and gfLowGravity) <> 0 then |
|
4623 | 1204 |
begin |
3355
dc9e61e67484
cWindSpeed recalculation assumed GetRandom returns a value between 0.0-1.0 while in fact is in the 0.0-0.5 range; Halve cMaxWindSpeed to compensate.
palewolf
parents:
3350
diff
changeset
|
1205 |
cGravity:= cMaxWindSpeed; |
4623 | 1206 |
cGravityf:= 0.00025 |
1207 |
end; |
|
1895 | 1208 |
|
2017 | 1209 |
if (GameFlags and gfVampiric) <> 0 then |
1210 |
cVampiric:= true; |
|
1211 |
||
1895 | 1212 |
Gear:= GearsList; |
1213 |
if (GameFlags and gfInvulnerable) <> 0 then |
|
1214 |
while Gear <> nil do |
|
1215 |
begin |
|
1216 |
Gear^.Invulnerable:= true; // this is only checked on hogs right now, so no need for gear type check |
|
1217 |
Gear:= Gear^.NextGear |
|
1218 |
end; |
|
1219 |
||
1220 |
if (GameFlags and gfLaserSight) <> 0 then |
|
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
1221 |
cLaserSighting:= true; |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
1222 |
|
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
1223 |
if (GameFlags and gfArtillery) <> 0 then |
4611 | 1224 |
cArtillery:= true; |
1225 |
||
5015 | 1226 |
if not hasBorder and ((Theme = 'Snow') or (Theme = 'Christmas')) then |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4669
diff
changeset
|
1227 |
begin |
4621 | 1228 |
for i:= 0 to Pred(vobCount*2) do |
4809
9c7d5f802618
rearrange quality flags a little, disable snow rendering on rqLowRes
koda
parents:
4808
diff
changeset
|
1229 |
AddGear(GetRandom(LAND_WIDTH+1024)-512, LAND_HEIGHT - GetRandom(LAND_HEIGHT div 2), gtFlake, 0, _0, _0, 0); |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4669
diff
changeset
|
1230 |
disableLandBack:= true |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4669
diff
changeset
|
1231 |
end |
4 | 1232 |
end; |
1233 |
||
4837
2ea0a152c319
Pass PHedgehog instead of PGear to stats. Fixes crash.
unc0rr
parents:
4835
diff
changeset
|
1234 |
procedure doMakeExplosion(X, Y, Radius: LongInt; AttackingHog: PHedgehog; Mask: Longword; const Tint: LongWord); |
4 | 1235 |
var Gear: PGear; |
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1236 |
dmg, dmgRadius, dmgBase: LongInt; |
3322 | 1237 |
fX, fY: hwFloat; |
3475 | 1238 |
vg: PVisualGear; |
3689 | 1239 |
i, cnt: LongInt; |
4 | 1240 |
begin |
4900 | 1241 |
if Radius > 4 then AddFileLog('Explosion: at (' + inttostr(x) + ',' + inttostr(y) + ')'); |
3083
8da8f2515221
Eliminate flake kick on themes with no flakes, more than 200 flakes (city) or explosions of 25 or smaller
nemo
parents:
3080
diff
changeset
|
1242 |
if Radius > 25 then KickFlakes(Radius, X, Y); |
8da8f2515221
Eliminate flake kick on themes with no flakes, more than 200 flakes (city) or explosions of 25 or smaller
nemo
parents:
3080
diff
changeset
|
1243 |
|
3032 | 1244 |
if ((Mask and EXPLNoGfx) = 0) then |
1245 |
begin |
|
3475 | 1246 |
vg:= nil; |
1247 |
if Radius > 50 then vg:= AddVisualGear(X, Y, vgtBigExplosion) |
|
1248 |
else if Radius > 10 then vg:= AddVisualGear(X, Y, vgtExplosion); |
|
1249 |
if vg <> nil then |
|
1250 |
vg^.Tint:= Tint; |
|
3032 | 1251 |
end; |
2745 | 1252 |
if (Mask and EXPLAutoSound) <> 0 then PlaySound(sndExplosion); |
1433 | 1253 |
|
1254 |
if (Mask and EXPLAllDamageInRadius) = 0 then |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1255 |
dmgRadius:= Radius shl 1 |
1433 | 1256 |
else |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1257 |
dmgRadius:= Radius; |
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1258 |
dmgBase:= dmgRadius + cHHRadius div 2; |
3322 | 1259 |
fX:= int2hwFloat(X); |
1260 |
fY:= int2hwFloat(Y); |
|
4 | 1261 |
Gear:= GearsList; |
1262 |
while Gear <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1263 |
begin |
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1264 |
dmg:= 0; |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1265 |
//dmg:= dmgRadius + cHHRadius div 2 - hwRound(Distance(Gear^.X - int2hwFloat(X), Gear^.Y - int2hwFloat(Y))); |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1266 |
//if (dmg > 1) and |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1267 |
if (Gear^.State and gstNoDamage) = 0 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1268 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1269 |
case Gear^.Kind of |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1270 |
gtHedgehog, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1271 |
gtMine, |
3710 | 1272 |
gtSMine, |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1273 |
gtCase, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1274 |
gtTarget, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1275 |
gtFlame, |
4881
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4867
diff
changeset
|
1276 |
gtExplosives, |
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4867
diff
changeset
|
1277 |
gtStructure: begin |
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1278 |
// Run the calcs only once we know we have a type that will need damage |
3322 | 1279 |
if hwRound(hwAbs(Gear^.X-fX)+hwAbs(Gear^.Y-fY)) < dmgBase then |
5139
090a8b8d1083
grenade back to old damage, but from now on explosions assume they are not closer to a gear's center than the gear's radius
sheepluva
parents:
5137
diff
changeset
|
1280 |
dmg:= dmgBase - max(hwRound(Distance(Gear^.X - fX, Gear^.Y - fY)),Gear^.Radius); |
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1281 |
if dmg > 1 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1282 |
begin |
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1283 |
dmg:= ModifyDamage(min(dmg div 2, Radius), Gear); |
4900 | 1284 |
//AddFileLog('Damage: ' + inttostr(dmg)); |
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1285 |
if (Mask and EXPLNoDamage) = 0 then |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1286 |
begin |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1287 |
if not Gear^.Invulnerable then |
4837
2ea0a152c319
Pass PHedgehog instead of PGear to stats. Fixes crash.
unc0rr
parents:
4835
diff
changeset
|
1288 |
ApplyDamage(Gear, AttackingHog, dmg, dsExplosion) |
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1289 |
else |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1290 |
Gear^.State:= Gear^.State or gstWinner; |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1291 |
end; |
3712 | 1292 |
if ((Mask and EXPLDoNotTouchAny) = 0) and (((Mask and EXPLDoNotTouchHH) = 0) or (Gear^.Kind <> gtHedgehog)) then |
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1293 |
begin |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1294 |
DeleteCI(Gear); |
3322 | 1295 |
Gear^.dX:= Gear^.dX + SignAs(_0_005 * dmg + cHHKick, Gear^.X - fX); |
1296 |
Gear^.dY:= Gear^.dY + SignAs(_0_005 * dmg + cHHKick, Gear^.Y - fY); |
|
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1297 |
Gear^.State:= (Gear^.State or gstMoving) and (not gstLoser); |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1298 |
if not Gear^.Invulnerable then |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1299 |
Gear^.State:= (Gear^.State or gstMoving) and (not gstWinner); |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1300 |
Gear^.Active:= true; |
3997 | 1301 |
if Gear^.Kind <> gtFlame then FollowGear:= Gear |
3112 | 1302 |
end; |
1303 |
if ((Mask and EXPLPoisoned) <> 0) and (Gear^.Kind = gtHedgehog) then |
|
4365 | 1304 |
Gear^.Hedgehog^.Effects[hePoisoned] := true; |
3112 | 1305 |
end; |
3100 | 1306 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1307 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1308 |
gtGrave: begin |
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1309 |
// Run the calcs only once we know we have a type that will need damage |
3322 | 1310 |
if hwRound(hwAbs(Gear^.X-fX)+hwAbs(Gear^.Y-fY)) < dmgBase then |
1311 |
dmg:= dmgBase - hwRound(Distance(Gear^.X - fX, Gear^.Y - fY)); |
|
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1312 |
if dmg > 1 then |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1313 |
begin |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1314 |
dmg:= ModifyDamage(min(dmg div 2, Radius), Gear); |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1315 |
Gear^.dY:= - _0_004 * dmg; |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1316 |
Gear^.Active:= true |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
1317 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1318 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1319 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1320 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1321 |
Gear:= Gear^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1322 |
end; |
1200 | 1323 |
|
621 | 1324 |
if (Mask and EXPLDontDraw) = 0 then |
3689 | 1325 |
if (GameFlags and gfSolidLand) = 0 then |
1326 |
begin |
|
1327 |
cnt:= DrawExplosion(X, Y, Radius) div 1608; // approx 2 16x16 circles to erase per chunk |
|
5284
34abd278344e
Remove default transparent chunks. Chunk will only be added if theme defined.
nemo
parents:
5279
diff
changeset
|
1328 |
if (cnt > 0) and (SpritesData[sprChunk].Texture <> nil) then |
3689 | 1329 |
for i:= 0 to cnt do |
1330 |
AddVisualGear(X, Y, vgtChunk) |
|
1331 |
end; |
|
1200 | 1332 |
|
498 | 1333 |
uAIMisc.AwareOfExplosion(0, 0, 0) |
4 | 1334 |
end; |
1335 |
||
506 | 1336 |
procedure ShotgunShot(Gear: PGear); |
1337 |
var t: PGear; |
|
5586
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1338 |
dmg, r, dist: LongInt; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1339 |
dx, dy: hwFloat; |
506 | 1340 |
begin |
509 | 1341 |
Gear^.Radius:= cShotgunRadius; |
506 | 1342 |
t:= GearsList; |
1343 |
while t <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1344 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1345 |
case t^.Kind of |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1346 |
gtHedgehog, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1347 |
gtMine, |
3710 | 1348 |
gtSMine, |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1349 |
gtCase, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1350 |
gtTarget, |
4881
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4867
diff
changeset
|
1351 |
gtExplosives, |
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4867
diff
changeset
|
1352 |
gtStructure: begin |
5586
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1353 |
//addFileLog('ShotgunShot radius: ' + inttostr(Gear^.Radius) + ', t^.Radius = ' + inttostr(t^.Radius) + ', distance = ' + inttostr(dist) + ', dmg = ' + inttostr(dmg)); |
5590 | 1354 |
dmg:= 0; |
5586
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1355 |
r:= Gear^.Radius + t^.Radius; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1356 |
dx:= Gear^.X-t^.X; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1357 |
dx.isNegative:= false; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1358 |
dy:= Gear^.Y-t^.Y; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1359 |
dy.isNegative:= false; |
5590 | 1360 |
if r-hwRound(dx+dy) > 0 then |
5586
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1361 |
begin |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1362 |
dist:= hwRound(Distance(dx, dy)); |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1363 |
dmg:= ModifyDamage(min(r - dist, 25), t); |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1364 |
end; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1365 |
if dmg > 0 then |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1366 |
begin |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1367 |
if (not t^.Invulnerable) then |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1368 |
ApplyDamage(t, Gear^.Hedgehog, dmg, dsBullet) |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1369 |
else |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1370 |
Gear^.State:= Gear^.State or gstWinner; |
867 | 1371 |
|
5586
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1372 |
DeleteCI(t); |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1373 |
t^.dX:= t^.dX + Gear^.dX * dmg * _0_01 + SignAs(cHHKick, Gear^.dX); |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1374 |
t^.dY:= t^.dY + Gear^.dY * dmg * _0_01; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1375 |
t^.State:= t^.State or gstMoving; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1376 |
t^.Active:= true; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1377 |
FollowGear:= t |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1378 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1379 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1380 |
gtGrave: begin |
5590 | 1381 |
dmg:= 0; |
5586
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1382 |
r:= Gear^.Radius + t^.Radius; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1383 |
dx:= Gear^.X-t^.X; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1384 |
dx.isNegative:= false; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1385 |
dy:= Gear^.Y-t^.Y; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1386 |
dy.isNegative:= false; |
5590 | 1387 |
if r-hwRound(dx+dy) > 0 then |
5586
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1388 |
begin |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1389 |
dist:= hwRound(Distance(dx, dy)); |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1390 |
dmg:= ModifyDamage(min(r - dist, 25), t); |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1391 |
end; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1392 |
if dmg > 0 then |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1393 |
begin |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1394 |
t^.dY:= - _0_1; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1395 |
t^.Active:= true |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
1396 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1397 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1398 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1399 |
t:= t^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1400 |
end; |
621 | 1401 |
if (GameFlags and gfSolidLand) = 0 then DrawExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), cShotgunRadius) |
506 | 1402 |
end; |
1403 |
||
371 | 1404 |
procedure AmmoShove(Ammo: PGear; Damage, Power: LongInt); |
53 | 1405 |
var t: PGearArray; |
2424
b52344de23ae
In progress, trying to make a fire for molotov cocktail. Normal fire should still work fairly normally.
nemo
parents:
2407
diff
changeset
|
1406 |
Gear: PGear; |
2726 | 1407 |
i, tmpDmg: LongInt; |
4327 | 1408 |
VGear: PVisualGear; |
38 | 1409 |
begin |
53 | 1410 |
t:= CheckGearsCollision(Ammo); |
3098
e5a1bc4e56fd
Specifically check for current hedgehog being on rope, the tricky bastard.
nemo
parents:
3097
diff
changeset
|
1411 |
// Just to avoid hogs on rope dodging fire. |
3697 | 1412 |
if (CurAmmoGear <> nil) and (CurAmmoGear^.Kind = gtRope) and |
1413 |
(CurrentHedgehog^.Gear <> nil) and (CurrentHedgehog^.Gear^.CollisionIndex = -1) and |
|
1414 |
(sqr(hwRound(Ammo^.X) - hwRound(CurrentHedgehog^.Gear^.X)) + sqr(hwRound(Ammo^.Y) - hwRound(CurrentHedgehog^.Gear^.Y)) <= sqr(cHHRadius + Ammo^.Radius)) then |
|
3098
e5a1bc4e56fd
Specifically check for current hedgehog being on rope, the tricky bastard.
nemo
parents:
3097
diff
changeset
|
1415 |
begin |
e5a1bc4e56fd
Specifically check for current hedgehog being on rope, the tricky bastard.
nemo
parents:
3097
diff
changeset
|
1416 |
t^.ar[t^.Count]:= CurrentHedgehog^.Gear; |
e5a1bc4e56fd
Specifically check for current hedgehog being on rope, the tricky bastard.
nemo
parents:
3097
diff
changeset
|
1417 |
inc(t^.Count) |
4182 | 1418 |
end; |
4165 | 1419 |
|
351 | 1420 |
i:= t^.Count; |
1506 | 1421 |
|
2489 | 1422 |
if (Ammo^.Kind = gtFlame) and (i > 0) then Ammo^.Health:= 0; |
53 | 1423 |
while i > 0 do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1424 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1425 |
dec(i); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1426 |
Gear:= t^.ar[i]; |
2726 | 1427 |
tmpDmg:= ModifyDamage(Damage, Gear); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1428 |
if (Gear^.State and gstNoDamage) = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1429 |
begin |
4824 | 1430 |
|
4329 | 1431 |
if (Ammo^.Kind = gtDEagleShot) or (Ammo^.Kind = gtSniperRifleShot) then |
4578 | 1432 |
begin |
4329 | 1433 |
VGear := AddVisualGear(hwround(Ammo^.X), hwround(Ammo^.Y), vgtBulletHit); |
4578 | 1434 |
if VGear <> nil then VGear^.Angle := DxDy2Angle(-Ammo^.dX, Ammo^.dY); |
4329 | 1435 |
end; |
4824 | 1436 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1437 |
if (Gear^.Kind = gtHedgehog) and (Ammo^.State and gsttmpFlag <> 0) and (Ammo^.Kind = gtShover) then Gear^.FlightTime:= 1; |
3697 | 1438 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1439 |
case Gear^.Kind of |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1440 |
gtHedgehog, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1441 |
gtMine, |
3710 | 1442 |
gtSMine, |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1443 |
gtTarget, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1444 |
gtCase, |
4881
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4867
diff
changeset
|
1445 |
gtExplosives, |
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4867
diff
changeset
|
1446 |
gtStructure: begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1447 |
if (Ammo^.Kind = gtDrill) then begin Ammo^.Timer:= 0; exit; end; |
2424
b52344de23ae
In progress, trying to make a fire for molotov cocktail. Normal fire should still work fairly normally.
nemo
parents:
2407
diff
changeset
|
1448 |
if (not Gear^.Invulnerable) then |
4837
2ea0a152c319
Pass PHedgehog instead of PGear to stats. Fixes crash.
unc0rr
parents:
4835
diff
changeset
|
1449 |
ApplyDamage(Gear, Ammo^.Hedgehog, tmpDmg, dsShove) |
1865
ebc6dfca60d4
- nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1863
diff
changeset
|
1450 |
else |
2424
b52344de23ae
In progress, trying to make a fire for molotov cocktail. Normal fire should still work fairly normally.
nemo
parents:
2407
diff
changeset
|
1451 |
Gear^.State:= Gear^.State or gstWinner; |
4837
2ea0a152c319
Pass PHedgehog instead of PGear to stats. Fixes crash.
unc0rr
parents:
4835
diff
changeset
|
1452 |
if (Gear^.Kind = gtExplosives) and (Ammo^.Kind = gtBlowtorch) then ApplyDamage(Gear, Ammo^.Hedgehog, tmpDmg * 100, dsUnknown); // crank up damage for explosives + blowtorch |
867 | 1453 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1454 |
DeleteCI(Gear); |
4365 | 1455 |
if (Gear^.Kind = gtHedgehog) and Gear^.Hedgehog^.King then |
2728
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1456 |
begin |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1457 |
Gear^.dX:= Ammo^.dX * Power * _0_005; |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1458 |
Gear^.dY:= Ammo^.dY * Power * _0_005 |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1459 |
end |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1460 |
else |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1461 |
begin |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1462 |
Gear^.dX:= Ammo^.dX * Power * _0_01; |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1463 |
Gear^.dY:= Ammo^.dY * Power * _0_01 |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1464 |
end; |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1465 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1466 |
Gear^.Active:= true; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1467 |
Gear^.State:= Gear^.State or gstMoving; |
867 | 1468 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1469 |
if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1470 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1471 |
if not (TestCollisionXwithXYShift(Gear, _0, -3, hwSign(Gear^.dX)) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1472 |
or TestCollisionYwithGear(Gear, -1)) then Gear^.Y:= Gear^.Y - _1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1473 |
if not (TestCollisionXwithXYShift(Gear, _0, -2, hwSign(Gear^.dX)) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1474 |
or TestCollisionYwithGear(Gear, -1)) then Gear^.Y:= Gear^.Y - _1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1475 |
if not (TestCollisionXwithXYShift(Gear, _0, -1, hwSign(Gear^.dX)) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1476 |
or TestCollisionYwithGear(Gear, -1)) then Gear^.Y:= Gear^.Y - _1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1477 |
end; |
3697 | 1478 |
|
2537
aceebf0653f7
Disable followgear on ammoshove for napalm fire damage
nemo
parents:
2492
diff
changeset
|
1479 |
if (Ammo^.Kind <> gtFlame) or ((Ammo^.State and gsttmpFlag) = 0) then FollowGear:= Gear |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1480 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1481 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1482 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1483 |
end; |
2424
b52344de23ae
In progress, trying to make a fire for molotov cocktail. Normal fire should still work fairly normally.
nemo
parents:
2407
diff
changeset
|
1484 |
if i <> 0 then SetAllToActive |
38 | 1485 |
end; |
1486 |
||
4 | 1487 |
procedure AssignHHCoords; |
955 | 1488 |
var i, t, p, j: LongInt; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1489 |
ar: array[0..Pred(cMaxHHs)] of PHedgehog; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1490 |
Count: Longword; |
4 | 1491 |
begin |
2771
477957a89881
Override both hog placements, this makes divide teams pretty much useless with hog placement mode. Restricting hog placement to one side might be a nice addition.
nemo
parents:
2770
diff
changeset
|
1492 |
if (GameFlags and gfPlaceHog) <> 0 then PlacingHogs:= true; |
4148
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
1493 |
if (GameFlags and gfDivideTeams) <> 0 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1494 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1495 |
t:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1496 |
TryDo(ClansCount = 2, 'More or less than 2 clans on map in divided teams mode!', true); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1497 |
for p:= 0 to 1 do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1498 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1499 |
with ClansArray[p]^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1500 |
for j:= 0 to Pred(TeamsNumber) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1501 |
with Teams[j]^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1502 |
for i:= 0 to cMaxHHIndex do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1503 |
with Hedgehogs[i] do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1504 |
if (Gear <> nil) and (Gear^.X.QWordValue = 0) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1505 |
begin |
2771
477957a89881
Override both hog placements, this makes divide teams pretty much useless with hog placement mode. Restricting hog placement to one side might be a nice addition.
nemo
parents:
2770
diff
changeset
|
1506 |
if PlacingHogs then Unplaced:= true |
477957a89881
Override both hog placements, this makes divide teams pretty much useless with hog placement mode. Restricting hog placement to one side might be a nice addition.
nemo
parents:
2770
diff
changeset
|
1507 |
else FindPlace(Gear, false, t, t + LAND_WIDTH div 2);// could make Gear == nil; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1508 |
if Gear <> nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1509 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1510 |
Gear^.Pos:= GetRandom(49); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1511 |
Gear^.dX.isNegative:= p = 1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1512 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1513 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1514 |
t:= LAND_WIDTH div 2 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1515 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1516 |
end else // mix hedgehogs |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1517 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1518 |
Count:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1519 |
for p:= 0 to Pred(TeamsCount) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1520 |
with TeamsArray[p]^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1521 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1522 |
for i:= 0 to cMaxHHIndex do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1523 |
with Hedgehogs[i] do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1524 |
if (Gear <> nil) and (Gear^.X.QWordValue = 0) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1525 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1526 |
ar[Count]:= @Hedgehogs[i]; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1527 |
inc(Count) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1528 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1529 |
end; |
1792 | 1530 |
// unC0Rr, while it is true user can watch value on map screen, IMO this (and check above) should be enforced in UI |
1531 |
// - is there a good place to put values for the different widgets to check? Right now they are kind of disconnected. |
|
1965 | 1532 |
//it would be nice if divide teams, forts mode and hh per map could all be checked by the team widget, or maybe disable start button |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1533 |
TryDo(Count <= MaxHedgehogs, 'Too many hedgehogs for this map! (max # is ' + inttostr(MaxHedgehogs) + ')', true); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1534 |
while (Count > 0) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1535 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1536 |
i:= GetRandom(Count); |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2760
diff
changeset
|
1537 |
if PlacingHogs then ar[i]^.Unplaced:= true |
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2760
diff
changeset
|
1538 |
else FindPlace(ar[i]^.Gear, false, 0, LAND_WIDTH); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1539 |
if ar[i]^.Gear <> nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1540 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1541 |
ar[i]^.Gear^.dX.isNegative:= hwRound(ar[i]^.Gear^.X) > LAND_WIDTH div 2; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1542 |
ar[i]^.Gear^.Pos:= GetRandom(19) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1543 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1544 |
ar[i]:= ar[Count - 1]; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1545 |
dec(Count) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1546 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1547 |
end |
4 | 1548 |
end; |
1549 |
||
4024
1ffb84b3823d
Resurrector: respect modified Gear position for resurrection range circle
Tobias Neumann <mail@tobias-neumann.eu>
parents:
4007
diff
changeset
|
1550 |
function GearsNear(X, Y: hwFloat; Kind: TGearType; r: LongInt): TPGearArray; |
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1551 |
var |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1552 |
t: PGear; |
5556 | 1553 |
l: Longword; |
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1554 |
begin |
4830
c5ddc3e6c8a4
Don't waste CPU cycles trying to find a piece of land when there's no free land left
unc0rr
parents:
4826
diff
changeset
|
1555 |
r:= r*r; |
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1556 |
GearsNear := nil; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1557 |
t := GearsList; |
5556 | 1558 |
while t <> nil do |
1559 |
begin |
|
1560 |
if (t^.Kind = Kind) |
|
1561 |
and ((X - t^.X)*(X - t^.X) + (Y - t^.Y)*(Y-t^.Y) < int2hwFloat(r)) then |
|
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1562 |
begin |
5556 | 1563 |
l:= Length(GearsNear); |
1564 |
SetLength(GearsNear, l + 1); |
|
1565 |
GearsNear[l] := t; |
|
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1566 |
end; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1567 |
t := t^.NextGear; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1568 |
end; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1569 |
end; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1570 |
|
371 | 1571 |
function CheckGearNear(Gear: PGear; Kind: TGearType; rX, rY: LongInt): PGear; |
10 | 1572 |
var t: PGear; |
1573 |
begin |
|
1574 |
t:= GearsList; |
|
1575 |
rX:= sqr(rX); |
|
1576 |
rY:= sqr(rY); |
|
1433 | 1577 |
|
10 | 1578 |
while t <> nil do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1579 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1580 |
if (t <> Gear) and (t^.Kind = Kind) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1581 |
if not((hwSqr(Gear^.X - t^.X) / rX + hwSqr(Gear^.Y - t^.Y) / rY) > _1) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1582 |
exit(t); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1583 |
t:= t^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1584 |
end; |
1433 | 1585 |
|
351 | 1586 |
CheckGearNear:= nil |
15 | 1587 |
end; |
1588 |
||
1433 | 1589 |
{procedure AmmoFlameWork(Ammo: PGear); |
79 | 1590 |
var t: PGear; |
1591 |
begin |
|
1592 |
t:= GearsList; |
|
1593 |
while t <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1594 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1595 |
if (t^.Kind = gtHedgehog) and (t^.Y < Ammo^.Y) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1596 |
if not (hwSqr(Ammo^.X - t^.X) + hwSqr(Ammo^.Y - t^.Y - int2hwFloat(cHHRadius)) * 2 > _2) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1597 |
begin |
2017 | 1598 |
ApplyDamage(t, 5); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1599 |
t^.dX:= t^.dX + (t^.X - Ammo^.X) * _0_02; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1600 |
t^.dY:= - _0_25; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1601 |
t^.Active:= true; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1602 |
DeleteCI(t); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1603 |
FollowGear:= t |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1604 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1605 |
t:= t^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1606 |
end; |
1433 | 1607 |
end;} |
79 | 1608 |
|
371 | 1609 |
function CheckGearsNear(mX, mY: LongInt; Kind: TGearsType; rX, rY: LongInt): PGear; |
16 | 1610 |
var t: PGear; |
1611 |
begin |
|
1612 |
t:= GearsList; |
|
1613 |
rX:= sqr(rX); |
|
1614 |
rY:= sqr(rY); |
|
1615 |
while t <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1616 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1617 |
if t^.Kind in Kind then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1618 |
if not (hwSqr(int2hwFloat(mX) - t^.X) / rX + hwSqr(int2hwFloat(mY) - t^.Y) / rY > _1) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1619 |
exit(t); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1620 |
t:= t^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1621 |
end; |
351 | 1622 |
CheckGearsNear:= nil |
16 | 1623 |
end; |
1624 |
||
1625 |
function CountGears(Kind: TGearType): Longword; |
|
1626 |
var t: PGear; |
|
2695 | 1627 |
count: Longword = 0; |
16 | 1628 |
begin |
2695 | 1629 |
|
16 | 1630 |
t:= GearsList; |
1631 |
while t <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1632 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1633 |
if t^.Kind = Kind then inc(count); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1634 |
t:= t^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1635 |
end; |
2695 | 1636 |
CountGears:= count; |
16 | 1637 |
end; |
1638 |
||
3768 | 1639 |
procedure ResurrectHedgehog(gear: PGear); |
3831
3410db7ac43e
gfAISurvival: fix issue when cpu cannot find new place to spawn
burp
parents:
3799
diff
changeset
|
1640 |
var tempTeam : PTeam; |
3768 | 1641 |
begin |
1642 |
gear^.dX := _0; |
|
1643 |
gear^.dY := _0; |
|
3775
c0397452e7c5
gfAISurvival/heResurrectable: respawn always with 100HP
burp
parents:
3773
diff
changeset
|
1644 |
gear^.Damage := 0; |
4455
a0c8779713f2
In AI survival mode, have the AI score when it kills humans, instead of its own team, clear poison on an AI kill, and reset AI health using InitialHealth instead of 100.
nemo
parents:
4443
diff
changeset
|
1645 |
gear^.Health := gear^.Hedgehog^.InitialHealth; |
a0c8779713f2
In AI survival mode, have the AI score when it kills humans, instead of its own team, clear poison on an AI kill, and reset AI health using InitialHealth instead of 100.
nemo
parents:
4443
diff
changeset
|
1646 |
gear^.Hedgehog^.Effects[hePoisoned] := false; |
a0c8779713f2
In AI survival mode, have the AI score when it kills humans, instead of its own team, clear poison on an AI kill, and reset AI health using InitialHealth instead of 100.
nemo
parents:
4443
diff
changeset
|
1647 |
if not CurrentHedgehog^.Effects[heResurrectable] then |
a0c8779713f2
In AI survival mode, have the AI score when it kills humans, instead of its own team, clear poison on an AI kill, and reset AI health using InitialHealth instead of 100.
nemo
parents:
4443
diff
changeset
|
1648 |
with CurrentHedgehog^ do |
a0c8779713f2
In AI survival mode, have the AI score when it kills humans, instead of its own team, clear poison on an AI kill, and reset AI health using InitialHealth instead of 100.
nemo
parents:
4443
diff
changeset
|
1649 |
begin |
a0c8779713f2
In AI survival mode, have the AI score when it kills humans, instead of its own team, clear poison on an AI kill, and reset AI health using InitialHealth instead of 100.
nemo
parents:
4443
diff
changeset
|
1650 |
inc(Team^.stats.AIKills); |
a0c8779713f2
In AI survival mode, have the AI score when it kills humans, instead of its own team, clear poison on an AI kill, and reset AI health using InitialHealth instead of 100.
nemo
parents:
4443
diff
changeset
|
1651 |
if Team^.AIKillsTex <> nil then FreeTexture(Team^.AIKillsTex); |
a0c8779713f2
In AI survival mode, have the AI score when it kills humans, instead of its own team, clear poison on an AI kill, and reset AI health using InitialHealth instead of 100.
nemo
parents:
4443
diff
changeset
|
1652 |
Team^.AIKillsTex := RenderStringTex(inttostr(Team^.stats.AIKills), Team^.Clan^.Color, fnt16); |
a0c8779713f2
In AI survival mode, have the AI score when it kills humans, instead of its own team, clear poison on an AI kill, and reset AI health using InitialHealth instead of 100.
nemo
parents:
4443
diff
changeset
|
1653 |
end; |
4372 | 1654 |
tempTeam := gear^.Hedgehog^.Team; |
3832
f949798219bf
Delete CI in ResurrectHedgehog prior to FindPlace. Restrict FindPlace to the waterline, a bit more efficient.
nemo
parents:
3831
diff
changeset
|
1655 |
DeleteCI(gear); |
4443
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1656 |
FindPlace(gear, false, 0, LAND_WIDTH, true); |
3831
3410db7ac43e
gfAISurvival: fix issue when cpu cannot find new place to spawn
burp
parents:
3799
diff
changeset
|
1657 |
if gear <> nil then begin |
4372 | 1658 |
RenderHealth(gear^.Hedgehog^); |
3848 | 1659 |
ScriptCall('onGearResurrect', gear^.uid); |
5498
fac3c15707d2
move gstWait - should make detecting drowning easier for mikade
nemo
parents:
5490
diff
changeset
|
1660 |
gear^.State := gstWait; |
3831
3410db7ac43e
gfAISurvival: fix issue when cpu cannot find new place to spawn
burp
parents:
3799
diff
changeset
|
1661 |
end; |
3410db7ac43e
gfAISurvival: fix issue when cpu cannot find new place to spawn
burp
parents:
3799
diff
changeset
|
1662 |
RecountTeamHealth(tempTeam); |
3768 | 1663 |
end; |
1664 |
||
3750
3aa85b5f3318
SpawnCustomCrateAt: spawn crate at random position for x=y=0, also let it return the gear, and luabindings the gear uid
burp
parents:
3749
diff
changeset
|
1665 |
function SpawnCustomCrateAt(x, y: LongInt; crate: TCrateType; content: Longword): PGear; |
3730 | 1666 |
begin |
3734 | 1667 |
FollowGear := AddGear(x, y, gtCase, 0, _0, _0, 0); |
1668 |
cCaseFactor := 0; |
|
1669 |
||
5313
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1670 |
if (crate <> HealthCrate) and (content > ord(High(TAmmoType))) then content := ord(High(TAmmoType)); |
3734 | 1671 |
|
1672 |
case crate of |
|
1673 |
HealthCrate: begin |
|
1674 |
FollowGear^.Pos := posCaseHealth; |
|
5313
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1675 |
FollowGear^.Health := content; |
3734 | 1676 |
AddCaption(GetEventString(eidNewHealthPack), cWhiteColor, capgrpAmmoInfo); |
1677 |
end; |
|
1678 |
AmmoCrate: begin |
|
1679 |
FollowGear^.Pos := posCaseAmmo; |
|
4240
4e81670e52aa
er. and cast to TAmmoType, which burp's routine still requires :)
nemo
parents:
4239
diff
changeset
|
1680 |
FollowGear^.AmmoType := TAmmoType(content); |
3734 | 1681 |
AddCaption(GetEventString(eidNewAmmoPack), cWhiteColor, capgrpAmmoInfo); |
1682 |
end; |
|
1683 |
UtilityCrate: begin |
|
1684 |
FollowGear^.Pos := posCaseUtility; |
|
4240
4e81670e52aa
er. and cast to TAmmoType, which burp's routine still requires :)
nemo
parents:
4239
diff
changeset
|
1685 |
FollowGear^.AmmoType := TAmmoType(content); |
3734 | 1686 |
AddCaption(GetEventString(eidNewUtilityPack), cWhiteColor, capgrpAmmoInfo); |
1687 |
end; |
|
1688 |
end; |
|
3750
3aa85b5f3318
SpawnCustomCrateAt: spawn crate at random position for x=y=0, also let it return the gear, and luabindings the gear uid
burp
parents:
3749
diff
changeset
|
1689 |
|
3aa85b5f3318
SpawnCustomCrateAt: spawn crate at random position for x=y=0, also let it return the gear, and luabindings the gear uid
burp
parents:
3749
diff
changeset
|
1690 |
if ( (x = 0) and (y = 0) ) then FindPlace(FollowGear, true, 0, LAND_WIDTH); |
3aa85b5f3318
SpawnCustomCrateAt: spawn crate at random position for x=y=0, also let it return the gear, and luabindings the gear uid
burp
parents:
3749
diff
changeset
|
1691 |
|
3aa85b5f3318
SpawnCustomCrateAt: spawn crate at random position for x=y=0, also let it return the gear, and luabindings the gear uid
burp
parents:
3749
diff
changeset
|
1692 |
SpawnCustomCrateAt := FollowGear; |
3730 | 1693 |
end; |
1694 |
||
5343 | 1695 |
function SpawnFakeCrateAt(x, y: LongInt; crate: TCrateType; explode: boolean; poison: boolean): PGear; |
5313
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1696 |
begin |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1697 |
FollowGear := AddGear(x, y, gtCase, 0, _0, _0, 0); |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1698 |
cCaseFactor := 0; |
5343 | 1699 |
FollowGear^.Pos := posCaseDummy; |
5313
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1700 |
|
5343 | 1701 |
if explode then FollowGear^.Pos := FollowGear^.Pos + posCaseExplode; |
1702 |
if poison then FollowGear^.Pos := FollowGear^.Pos + posCasePoison; |
|
5313
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1703 |
|
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1704 |
case crate of |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1705 |
HealthCrate: begin |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1706 |
FollowGear^.Pos := FollowGear^.Pos + posCaseHealth; |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1707 |
AddCaption(GetEventString(eidNewHealthPack), cWhiteColor, capgrpAmmoInfo); |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1708 |
end; |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1709 |
AmmoCrate: begin |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1710 |
FollowGear^.Pos := FollowGear^.Pos + posCaseAmmo; |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1711 |
AddCaption(GetEventString(eidNewAmmoPack), cWhiteColor, capgrpAmmoInfo); |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1712 |
end; |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1713 |
UtilityCrate: begin |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1714 |
FollowGear^.Pos := FollowGear^.Pos + posCaseUtility; |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1715 |
AddCaption(GetEventString(eidNewUtilityPack), cWhiteColor, capgrpAmmoInfo); |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1716 |
end; |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1717 |
end; |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1718 |
|
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1719 |
if ( (x = 0) and (y = 0) ) then FindPlace(FollowGear, true, 0, LAND_WIDTH); |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1720 |
|
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1721 |
SpawnFakeCrateAt := FollowGear; |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1722 |
end; |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1723 |
|
5584
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1724 |
function GetAmmo: TAmmoType; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1725 |
var t, aTot: LongInt; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1726 |
i: TAmmoType; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1727 |
begin |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1728 |
|
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1729 |
aTot:= 0; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1730 |
for i:= Low(TAmmoType) to High(TAmmoType) do |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1731 |
if (Ammoz[i].Ammo.Propz and ammoprop_Utility) = 0 then |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1732 |
inc(aTot, Ammoz[i].Probability); |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1733 |
|
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1734 |
t:= aTot; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1735 |
i:= Low(TAmmoType); |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1736 |
if (t > 0) then |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1737 |
begin |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1738 |
t:= GetRandom(t); |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1739 |
AddFileLog(inttostr(t)+' --------------'); |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1740 |
while t >= 0 do |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1741 |
begin |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1742 |
inc(i); |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1743 |
if (Ammoz[i].Ammo.Propz and ammoprop_Utility) = 0 then |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1744 |
dec(t, Ammoz[i].Probability) |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1745 |
end |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1746 |
end; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1747 |
GetAmmo:= i |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1748 |
end; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1749 |
|
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1750 |
function GetUtility: TAmmoType; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1751 |
var t, uTot: LongInt; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1752 |
i: TAmmoType; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1753 |
begin |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1754 |
|
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1755 |
uTot:= 0; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1756 |
for i:= Low(TAmmoType) to High(TAmmoType) do |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1757 |
if (Ammoz[i].Ammo.Propz and ammoprop_Utility) <> 0 then |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1758 |
inc(uTot, Ammoz[i].Probability); |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1759 |
|
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1760 |
t:= uTot; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1761 |
i:= Low(TAmmoType); |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1762 |
if (t > 0) then |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1763 |
begin |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1764 |
t:= GetRandom(t); |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1765 |
while t >= 0 do |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1766 |
begin |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1767 |
inc(i); |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1768 |
if (Ammoz[i].Ammo.Propz and ammoprop_Utility) <> 0 then |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1769 |
dec(t, Ammoz[i].Probability) |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1770 |
end |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1771 |
end; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1772 |
GetUtility:= i |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1773 |
end; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1774 |
|
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1775 |
|
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1776 |
|
15 | 1777 |
procedure SpawnBoxOfSmth; |
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1778 |
var t, aTot, uTot, a, h: LongInt; |
394
4c017ae1226a
- Implement hack to let ammo stores work without needed assistance of frontend
unc0rr
parents:
393
diff
changeset
|
1779 |
i: TAmmoType; |
15 | 1780 |
begin |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2760
diff
changeset
|
1781 |
if (PlacingHogs) or |
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2760
diff
changeset
|
1782 |
(cCaseFactor = 0) or |
614 | 1783 |
(CountGears(gtCase) >= 5) or |
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1784 |
(GetRandom(cCaseFactor) <> 0) then exit; |
1295 | 1785 |
|
1948 | 1786 |
FollowGear:= nil; |
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1787 |
aTot:= 0; |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1788 |
uTot:= 0; |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1789 |
for i:= Low(TAmmoType) to High(TAmmoType) do |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1790 |
if (Ammoz[i].Ammo.Propz and ammoprop_Utility) = 0 then |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1791 |
inc(aTot, Ammoz[i].Probability) |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1792 |
else |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1793 |
inc(uTot, Ammoz[i].Probability); |
1966 | 1794 |
|
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1795 |
t:=0; |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1796 |
a:=aTot; |
3268 | 1797 |
h:= 1; |
4143
eb7981f34800
Remove the last vestiges of the shoppa hack by adding 2 spinners for percentage health and amount of health in crate, also update translations and increase SD spinner (some users have requested it)
henek
parents:
4120
diff
changeset
|
1798 |
|
3268 | 1799 |
if (aTot+uTot) <> 0 then |
4143
eb7981f34800
Remove the last vestiges of the shoppa hack by adding 2 spinners for percentage health and amount of health in crate, also update translations and increase SD spinner (some users have requested it)
henek
parents:
4120
diff
changeset
|
1800 |
if ((GameFlags and gfInvulnerable) = 0) then |
3268 | 1801 |
begin |
4143
eb7981f34800
Remove the last vestiges of the shoppa hack by adding 2 spinners for percentage health and amount of health in crate, also update translations and increase SD spinner (some users have requested it)
henek
parents:
4120
diff
changeset
|
1802 |
h:= cHealthCaseProb * 100; |
3268 | 1803 |
t:= GetRandom(10000); |
4143
eb7981f34800
Remove the last vestiges of the shoppa hack by adding 2 spinners for percentage health and amount of health in crate, also update translations and increase SD spinner (some users have requested it)
henek
parents:
4120
diff
changeset
|
1804 |
a:= (10000-h)*aTot div (aTot+uTot) |
3268 | 1805 |
end |
3697 | 1806 |
else |
3268 | 1807 |
begin |
1808 |
t:= GetRandom(aTot+uTot); |
|
1809 |
h:= 0 |
|
1810 |
end; |
|
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1811 |
|
3697 | 1812 |
|
3261
fa7086253e83
Rebalance Default to take into account reweighting of crates, remove redundant check
nemo
parents:
3259
diff
changeset
|
1813 |
if t<h then |
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1814 |
begin |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1815 |
FollowGear:= AddGear(0, 0, gtCase, 0, _0, _0, 0); |
4143
eb7981f34800
Remove the last vestiges of the shoppa hack by adding 2 spinners for percentage health and amount of health in crate, also update translations and increase SD spinner (some users have requested it)
henek
parents:
4120
diff
changeset
|
1816 |
FollowGear^.Health:= cHealthCaseAmount; |
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1817 |
FollowGear^.Pos:= posCaseHealth; |
3331 | 1818 |
AddCaption(GetEventString(eidNewHealthPack), cWhiteColor, capgrpAmmoInfo); |
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1819 |
end |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1820 |
else if (t<a+h) then |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1821 |
begin |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1822 |
t:= aTot; |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1823 |
if (t > 0) then |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1824 |
begin |
1865
ebc6dfca60d4
- nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1863
diff
changeset
|
1825 |
FollowGear:= AddGear(0, 0, gtCase, 0, _0, _0, 0); |
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1826 |
t:= GetRandom(t); |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1827 |
i:= Low(TAmmoType); |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1828 |
FollowGear^.Pos:= posCaseAmmo; |
4238
6f1631765ebd
Fix a long-standing bug with ammo due to gstMoving being set on gears generically, causing an incorrect ammo type to be set. This caused crashes and incorrect ammo types.
nemo
parents:
4225
diff
changeset
|
1829 |
FollowGear^.AmmoType:= i; |
3331 | 1830 |
AddCaption(GetEventString(eidNewAmmoPack), cWhiteColor, capgrpAmmoInfo); |
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1831 |
end |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1832 |
end |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1833 |
else |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1834 |
begin |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1835 |
t:= uTot; |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1836 |
if (t > 0) then |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1837 |
begin |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1838 |
FollowGear:= AddGear(0, 0, gtCase, 0, _0, _0, 0); |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1839 |
t:= GetRandom(t); |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1840 |
i:= Low(TAmmoType); |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1841 |
FollowGear^.Pos:= posCaseUtility; |
4238
6f1631765ebd
Fix a long-standing bug with ammo due to gstMoving being set on gears generically, causing an incorrect ammo type to be set. This caused crashes and incorrect ammo types.
nemo
parents:
4225
diff
changeset
|
1842 |
FollowGear^.AmmoType:= i; |
3331 | 1843 |
AddCaption(GetEventString(eidNewUtilityPack), cWhiteColor, capgrpAmmoInfo); |
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1844 |
end |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1845 |
end; |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1846 |
|
1865
ebc6dfca60d4
- nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1863
diff
changeset
|
1847 |
// handles case of no ammo or utility crates - considered also placing booleans in uAmmos and altering probabilities |
ebc6dfca60d4
- nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1863
diff
changeset
|
1848 |
if (FollowGear <> nil) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1849 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1850 |
FindPlace(FollowGear, true, 0, LAND_WIDTH); |
2376 | 1851 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1852 |
if (FollowGear <> nil) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1853 |
PlaySound(sndReinforce, CurrentTeam^.voicepack) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1854 |
end |
70 | 1855 |
end; |
1856 |
||
4443
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1857 |
procedure FindPlace(var Gear: PGear; withFall: boolean; Left, Right: LongInt; skipProximity: boolean = false); |
70 | 1858 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1859 |
function CountNonZeroz(x, y, r, c: LongInt): LongInt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1860 |
var i: LongInt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1861 |
count: LongInt = 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1862 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1863 |
if (y and LAND_HEIGHT_MASK) = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1864 |
for i:= max(x - r, 0) to min(x + r, LAND_WIDTH - 4) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1865 |
if Land[y, i] <> 0 then |
2659 | 1866 |
begin |
2695 | 1867 |
inc(count); |
1868 |
if count = c then exit(count) |
|
2659 | 1869 |
end; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1870 |
CountNonZeroz:= count; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1871 |
end; |
70 | 1872 |
|
495 | 1873 |
var x: LongInt; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1874 |
y, sy: LongInt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1875 |
ar: array[0..511] of TPoint; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1876 |
ar2: array[0..1023] of TPoint; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1877 |
cnt, cnt2: Longword; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1878 |
delta: LongInt; |
4443
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1879 |
reallySkip, tryAgain: boolean; |
70 | 1880 |
begin |
4443
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1881 |
reallySkip:= false; // try not skipping proximity at first |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1882 |
tryAgain:= true; |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1883 |
while tryAgain do |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1884 |
begin |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1885 |
delta:= 250; |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1886 |
cnt2:= 0; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1887 |
repeat |
4443
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1888 |
x:= Left + LongInt(GetRandom(Delta)); |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1889 |
repeat |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1890 |
inc(x, Delta); |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1891 |
cnt:= 0; |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1892 |
y:= min(1024, topY) - 2 * Gear^.Radius; |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1893 |
while y < cWaterLine do |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1894 |
begin |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1895 |
repeat |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1896 |
inc(y, 2); |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1897 |
until (y >= cWaterLine) or (CountNonZeroz(x, y, Gear^.Radius - 1, 1) = 0); |
2376 | 1898 |
|
4443
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1899 |
sy:= y; |
1515 | 1900 |
|
4443
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1901 |
repeat |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1902 |
inc(y); |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1903 |
until (y >= cWaterLine) or (CountNonZeroz(x, y, Gear^.Radius - 1, 1) <> 0); |
3697 | 1904 |
|
4443
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1905 |
if (y - sy > Gear^.Radius * 2) and |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1906 |
(((Gear^.Kind = gtExplosives) |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1907 |
and (y < cWaterLine) |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1908 |
and (reallySkip or (CheckGearsNear(x, y - Gear^.Radius, [gtFlame, gtHedgehog, gtMine, gtCase, gtExplosives], 60, 60) = nil)) |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1909 |
and (CountNonZeroz(x, y+1, Gear^.Radius - 1, Gear^.Radius+1) > Gear^.Radius)) |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1910 |
or |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1911 |
((Gear^.Kind <> gtExplosives) |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1912 |
and (y < cWaterLine) |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1913 |
and (reallySkip or (CheckGearsNear(x, y - Gear^.Radius, [gtFlame, gtHedgehog, gtMine, gtCase, gtExplosives], 110, 110) = nil)))) then |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1914 |
begin |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1915 |
ar[cnt].X:= x; |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1916 |
if withFall then ar[cnt].Y:= sy + Gear^.Radius |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1917 |
else ar[cnt].Y:= y - Gear^.Radius; |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1918 |
inc(cnt) |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1919 |
end; |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1920 |
|
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1921 |
inc(y, 45) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1922 |
end; |
2376 | 1923 |
|
4443
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1924 |
if cnt > 0 then |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1925 |
with ar[GetRandom(cnt)] do |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1926 |
begin |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1927 |
ar2[cnt2].x:= x; |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1928 |
ar2[cnt2].y:= y; |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1929 |
inc(cnt2) |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1930 |
end |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1931 |
until (x + Delta > Right); |
2376 | 1932 |
|
4443
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1933 |
dec(Delta, 60) |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1934 |
until (cnt2 > 0) or (Delta < 70); |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1935 |
if (cnt2 = 0) and skipProximity and not reallySkip then tryAgain:= true |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1936 |
else tryAgain:= false; |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1937 |
reallySkip:= true; |
d393b9ccd328
Add an extra pass in FindPlace for AI resurrection mode to try to make it unwinnable, add DeleteGear, DeleteVisualGear, AddVisualGear, GetVisualGearValues, SetVisualGearValues to Lua
nemo
parents:
4417
diff
changeset
|
1938 |
end; |
1515 | 1939 |
|
386 | 1940 |
if cnt2 > 0 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1941 |
with ar2[GetRandom(cnt2)] do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1942 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1943 |
Gear^.X:= int2hwFloat(x); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1944 |
Gear^.Y:= int2hwFloat(y); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1945 |
AddFileLog('Assigned Gear coordinates (' + inttostr(x) + ',' + inttostr(y) + ')'); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1946 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1947 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1948 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1949 |
OutError('Can''t find place for Gear', false); |
4365 | 1950 |
if Gear^.Kind = gtHedgehog then Gear^.Hedgehog^.Effects[heResurrectable] := false; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1951 |
DeleteGear(Gear); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1952 |
Gear:= nil |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1953 |
end |
10 | 1954 |
end; |
1955 |
||
2726 | 1956 |
function ModifyDamage(dmg: Longword; Gear: PGear): Longword; |
2728
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1957 |
var i: hwFloat; |
2726 | 1958 |
begin |
1959 |
(* Invulnerability cannot be placed in here due to still needing kicks |
|
1960 |
Not without a new damage machine. |
|
1961 |
King check should be in here instead of ApplyDamage since Tiy wants them kicked less |
|
1962 |
*) |
|
2728
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1963 |
i:= _1; |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1964 |
if (CurrentHedgehog <> nil) and CurrentHedgehog^.King then i:= _1_5; |
4365 | 1965 |
if (Gear^.Hedgehog <> nil) and (Gear^.Hedgehog^.King) then |
2728
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1966 |
ModifyDamage:= hwRound(_0_01 * cDamageModifier * dmg * i * cDamagePercent * _0_5) |
2726 | 1967 |
else |
2728
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
1968 |
ModifyDamage:= hwRound(_0_01 * cDamageModifier * dmg * i * cDamagePercent) |
2726 | 1969 |
end; |
1970 |
||
2790 | 1971 |
function GearByUID(uid : Longword) : PGear; |
1972 |
var gear: PGear; |
|
1973 |
begin |
|
1974 |
GearByUID:= nil; |
|
4780
8571151411b3
add a couple of variables to speed up UID lookups. Based on the assumption new visual gears and gears will tend to be at the end of the list. Set them on successful lookup or script gear creation, clear on delete. Oh also pick up a couple of TrevInc's translation changes
nemo
parents:
4748
diff
changeset
|
1975 |
if uid = 0 then exit; |
8571151411b3
add a couple of variables to speed up UID lookups. Based on the assumption new visual gears and gears will tend to be at the end of the list. Set them on successful lookup or script gear creation, clear on delete. Oh also pick up a couple of TrevInc's translation changes
nemo
parents:
4748
diff
changeset
|
1976 |
if (lastGearByUID <> nil) and (lastGearByUID^.uid = uid) then |
8571151411b3
add a couple of variables to speed up UID lookups. Based on the assumption new visual gears and gears will tend to be at the end of the list. Set them on successful lookup or script gear creation, clear on delete. Oh also pick up a couple of TrevInc's translation changes
nemo
parents:
4748
diff
changeset
|
1977 |
begin |
8571151411b3
add a couple of variables to speed up UID lookups. Based on the assumption new visual gears and gears will tend to be at the end of the list. Set them on successful lookup or script gear creation, clear on delete. Oh also pick up a couple of TrevInc's translation changes
nemo
parents:
4748
diff
changeset
|
1978 |
GearByUID:= lastGearByUID; |
8571151411b3
add a couple of variables to speed up UID lookups. Based on the assumption new visual gears and gears will tend to be at the end of the list. Set them on successful lookup or script gear creation, clear on delete. Oh also pick up a couple of TrevInc's translation changes
nemo
parents:
4748
diff
changeset
|
1979 |
exit |
8571151411b3
add a couple of variables to speed up UID lookups. Based on the assumption new visual gears and gears will tend to be at the end of the list. Set them on successful lookup or script gear creation, clear on delete. Oh also pick up a couple of TrevInc's translation changes
nemo
parents:
4748
diff
changeset
|
1980 |
end; |
2790 | 1981 |
gear:= GearsList; |
1982 |
while gear <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1983 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1984 |
if gear^.uid = uid then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1985 |
begin |
4780
8571151411b3
add a couple of variables to speed up UID lookups. Based on the assumption new visual gears and gears will tend to be at the end of the list. Set them on successful lookup or script gear creation, clear on delete. Oh also pick up a couple of TrevInc's translation changes
nemo
parents:
4748
diff
changeset
|
1986 |
lastGearByUID:= gear; |
8571151411b3
add a couple of variables to speed up UID lookups. Based on the assumption new visual gears and gears will tend to be at the end of the list. Set them on successful lookup or script gear creation, clear on delete. Oh also pick up a couple of TrevInc's translation changes
nemo
parents:
4748
diff
changeset
|
1987 |
GearByUID:= gear; |
8571151411b3
add a couple of variables to speed up UID lookups. Based on the assumption new visual gears and gears will tend to be at the end of the list. Set them on successful lookup or script gear creation, clear on delete. Oh also pick up a couple of TrevInc's translation changes
nemo
parents:
4748
diff
changeset
|
1988 |
exit |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1989 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1990 |
gear:= gear^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1991 |
end |
2790 | 1992 |
end; |
1993 |
||
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1994 |
|
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1995 |
procedure chSkip(var s: shortstring); |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1996 |
begin |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1997 |
s:= s; // avoid compiler hint |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1998 |
if not CurrentTeam^.ExtDriven then SendIPC(','); |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1999 |
uStats.Skipped; |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
2000 |
skipFlag:= true |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
2001 |
end; |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
2002 |
|
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
2003 |
procedure chHogSay(var s: shortstring); |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
2004 |
var Gear: PVisualGear; |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
2005 |
text: shortstring; |
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2006 |
hh: PHedgehog; |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2007 |
i, x, t, h: byte; |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2008 |
c, j: LongInt; |
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
2009 |
begin |
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2010 |
hh:= nil; |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2011 |
i:= 0; |
4469 | 2012 |
t:= 0; |
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2013 |
x:= byte(s[1]); // speech type |
4469 | 2014 |
if x < 4 then |
2015 |
begin |
|
2016 |
t:= byte(s[2]); // team |
|
2017 |
if Length(s) > 2 then h:= byte(s[3]) // target hog |
|
2018 |
end; |
|
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2019 |
// allow targetting a hog by specifying a number as the first portion of the text |
4468 | 2020 |
if (x < 4) and (h > byte('0')) and (h < byte('9')) then i:= h - 48; |
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2021 |
if i <> 0 then text:= copy(s, 4, Length(s) - 1) |
4468 | 2022 |
else if x < 4 then text:= copy(s, 3, Length(s) - 1) |
2023 |
else text:= copy(s, 2, Length(s) - 1); |
|
2024 |
||
4470
d2b8d2fc51a9
disable say, just don't do anything. trying to avoid spew on spectator join
nemo
parents:
4469
diff
changeset
|
2025 |
(* |
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2026 |
if CheckNoTeamOrHH then |
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
2027 |
begin |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
2028 |
ParseCommand('say ' + text, true); |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
2029 |
exit |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
2030 |
end; |
4470
d2b8d2fc51a9
disable say, just don't do anything. trying to avoid spew on spectator join
nemo
parents:
4469
diff
changeset
|
2031 |
*) |
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
2032 |
|
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2033 |
if (x < 4) and (TeamsArray[t] <> nil) then |
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
2034 |
begin |
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2035 |
// if team matches current hedgehog team, default to current hedgehog |
4783 | 2036 |
if (i = 0) and (CurrentHedgehog <> nil) and (CurrentHedgehog^.Team = TeamsArray[t]) then hh:= CurrentHedgehog |
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2037 |
else |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2038 |
begin |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2039 |
// otherwise use the first living hog or the hog amongs the remaining ones indicated by i |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2040 |
j:= 0; |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2041 |
c:= 0; |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2042 |
while (j <= cMaxHHIndex) and (hh = nil) do |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2043 |
begin |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2044 |
if (TeamsArray[t]^.Hedgehogs[j].Gear <> nil) then |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2045 |
begin |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2046 |
inc(c); |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2047 |
if (i=0) or (i=c) then |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2048 |
hh:= @TeamsArray[t]^.Hedgehogs[j] |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2049 |
end; |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2050 |
inc(j) |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2051 |
end |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2052 |
end; |
4784 | 2053 |
if hh <> nil then |
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
2054 |
begin |
4784 | 2055 |
Gear:= AddVisualGear(0, 0, vgtSpeechBubble); |
2056 |
if Gear <> nil then |
|
2057 |
begin |
|
2058 |
Gear^.Hedgehog:= hh; |
|
2059 |
Gear^.Text:= text; |
|
2060 |
Gear^.FrameTicks:= x |
|
2061 |
end |
|
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
2062 |
end |
4706 | 2063 |
//else ParseCommand('say ' + text, true) |
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
2064 |
end |
4470
d2b8d2fc51a9
disable say, just don't do anything. trying to avoid spew on spectator join
nemo
parents:
4469
diff
changeset
|
2065 |
else if (x >= 4) then |
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
2066 |
begin |
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
2067 |
SpeechType:= x-3; |
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
2068 |
SpeechText:= text |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
2069 |
end; |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
2070 |
end; |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
2071 |
|
3038 | 2072 |
procedure initModule; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
2073 |
begin |
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
2074 |
RegisterVariable('skip', vtCommand, @chSkip, false); |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
2075 |
RegisterVariable('hogsay', vtCommand, @chHogSay, true ); |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
2076 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
2077 |
CurAmmoGear:= nil; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
2078 |
GearsList:= nil; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
2079 |
KilledHHs:= 0; |
4792
68f9b331014a
sudden death changes: only change visual bit on health decrease and support for water transparancy change and clouds number change
Henek
parents:
4790
diff
changeset
|
2080 |
SuddenDeath:= false; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
2081 |
SuddenDeathDmg:= false; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
2082 |
SpeechType:= 1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
2083 |
skipFlag:= false; |
3697 | 2084 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
2085 |
AllInactive:= false; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
2086 |
PrvInactive:= false; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
2087 |
end; |
4 | 2088 |
|
3038 | 2089 |
procedure freeModule; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
2090 |
begin |
3615 | 2091 |
FreeGearsList(); |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
2092 |
end; |
4 | 2093 |
|
2451
5affd0840927
New data files from Tiy, add gtFlame to avoidance list
nemo
parents:
2428
diff
changeset
|
2094 |
end. |