author | mikade |
Tue, 06 Dec 2011 05:41:52 +0200 (2011-12-06) | |
changeset 6505 | b005fbba039e |
parent 6472 | bced12412f94 |
child 6515 | 74a04089bb56 |
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; |
|
4976 | 40 |
function SpawnCustomCrateAt(x, y: LongInt; crate: TCrateType; content: Longword ): PGear; |
5343 | 41 |
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
|
42 |
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
|
43 |
function GetUtility: TAmmoType; |
5812 | 44 |
procedure HideHog(HH: PHedgehog); |
45 |
procedure RestoreHog(HH: PHedgehog); |
|
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; |
4 | 48 |
procedure SetAllToActive; |
49 |
procedure SetAllHHToActive; |
|
956 | 50 |
procedure DrawGears; |
4 | 51 |
procedure FreeGearsList; |
10 | 52 |
procedure AddMiscGears; |
4 | 53 |
procedure AssignHHCoords; |
3405 | 54 |
function GearByUID(uid : Longword) : PGear; |
294 | 55 |
procedure InsertGearToList(Gear: PGear); |
56 |
procedure RemoveGearFromList(Gear: PGear); |
|
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
|
57 |
procedure DeleteGear(Gear: PGear); |
4385 | 58 |
|
4 | 59 |
|
60 |
implementation |
|
4393 | 61 |
uses uStore, uSound, uTeams, uRandom, uCollisions, uIO, uLandGraphics, |
4373 | 62 |
uAIMisc, uLocale, uAI, uAmmos, uStats, uVisualGears, uScript, GLunit, uMobile, uVariables, |
6468 | 63 |
uCommands, uUtils, uTextures, uRenderUtils, uGearsRender, uCaptions, uDebug, uLandTexture, |
64 |
uGearsHedgehog; |
|
789 | 65 |
|
3697 | 66 |
|
371 | 67 |
procedure AmmoShove(Ammo: PGear; Damage, Power: LongInt); forward; |
1433 | 68 |
//procedure AmmoFlameWork(Ammo: PGear); forward; |
4034
634a8c8682de
add some phone rumbling to big explosions, airbomb and sinegun
koda
parents:
4024
diff
changeset
|
69 |
function GearsNear(X, Y: hwFloat; Kind: TGearType; r: LongInt): TPGearArray; forward; |
15 | 70 |
procedure SpawnBoxOfSmth; forward; |
506 | 71 |
procedure ShotgunShot(Gear: PGear); forward; |
1689 | 72 |
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
|
73 |
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
|
74 |
procedure doStepCase(Gear: PGear); forward; |
1964 | 75 |
|
5121
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
76 |
// 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
|
77 |
// separate files. |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
78 |
// 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
|
79 |
// than the handlers for all other gears. |
2599 | 80 |
{$INCLUDE "GSHandlers.inc"} |
4 | 81 |
|
82 |
const doStepHandlers: array[TGearType] of TGearStepProcedure = ( |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
83 |
@doStepBomb, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
84 |
@doStepHedgehog, |
4168 | 85 |
@doStepShell, |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
86 |
@doStepGrave, |
3080 | 87 |
@doStepBee, |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
88 |
@doStepShotgunShot, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
89 |
@doStepPickHammer, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
90 |
@doStepRope, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
91 |
@doStepMine, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
92 |
@doStepCase, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
93 |
@doStepDEagleShot, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
94 |
@doStepDynamite, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
95 |
@doStepBomb, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
96 |
@doStepCluster, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
97 |
@doStepShover, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
98 |
@doStepFlame, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
99 |
@doStepFirePunch, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
100 |
@doStepActionTimer, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
101 |
@doStepActionTimer, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
102 |
@doStepParachute, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
103 |
@doStepAirAttack, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
104 |
@doStepAirBomb, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
105 |
@doStepBlowTorch, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
106 |
@doStepGirder, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
107 |
@doStepTeleport, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
108 |
@doStepSwitcher, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
109 |
@doStepTarget, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
110 |
@doStepMortar, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
111 |
@doStepWhip, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
112 |
@doStepKamikaze, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
113 |
@doStepCake, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
114 |
@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
|
115 |
@doStepBomb, |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
116 |
@doStepCluster, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
117 |
@doStepBomb, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
118 |
@doStepWaterUp, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
119 |
@doStepDrill, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
120 |
@doStepBallgun, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
121 |
@doStepBomb, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
122 |
@doStepRCPlane, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
123 |
@doStepSniperRifleShot, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
124 |
@doStepJetpack, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
125 |
@doStepMolotov, |
2983 | 126 |
@doStepCase, |
3032 | 127 |
@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
|
128 |
@doStepEggWork, |
3428 | 129 |
@doStepPortalShot, |
3382 | 130 |
@doStepPiano, |
3384 | 131 |
@doStepBomb, |
3476
1ec68b8d3bd1
Henek adds a flamethrower, updates some translations, and tweaks how fire works.
nemo
parents:
3475
diff
changeset
|
132 |
@doStepSineGunShot, |
3710 | 133 |
@doStepFlamethrower, |
3712 | 134 |
@doStepSMine, |
3717 | 135 |
@doStepPoisonCloud, |
3720 | 136 |
@doStepHammer, |
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
137 |
@doStepHammerHit, |
4313
0690067bc5ff
made napalm use napalmbombs instead of just dropping fire
Henek
parents:
4299
diff
changeset
|
138 |
@doStepResurrector, |
4578 | 139 |
@doStepNapalmBomb, |
4611 | 140 |
@doStepSnowball, |
4881
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4867
diff
changeset
|
141 |
@doStepSnowflake, |
5279 | 142 |
@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
|
143 |
@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
|
144 |
@doStepTardis); |
4 | 145 |
|
146 |
function CheckNoDamage: boolean; // returns TRUE in case of no damaged hhs |
|
147 |
var Gear: PGear; |
|
1849 | 148 |
dmg: LongInt; |
4 | 149 |
begin |
351 | 150 |
CheckNoDamage:= true; |
4 | 151 |
Gear:= GearsList; |
152 |
while Gear <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
153 |
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
|
154 |
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
|
155 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
156 |
if (not isInMultiShoot) then inc(Gear^.Damage, Gear^.Karma); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
157 |
if (Gear^.Damage <> 0) and |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
158 |
(not Gear^.Invulnerable) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
159 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
160 |
CheckNoDamage:= false; |
4824 | 161 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
162 |
dmg:= Gear^.Damage; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
163 |
if Gear^.Health < dmg then |
3453 | 164 |
begin |
165 |
Gear^.Active:= true; |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
166 |
Gear^.Health:= 0 |
3453 | 167 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
168 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
169 |
dec(Gear^.Health, dmg); |
351 | 170 |
|
4365 | 171 |
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
|
172 |
(Gear^.Damage <> Gear^.Karma) and |
6453
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6380
diff
changeset
|
173 |
(not Gear^.Hedgehog^.King) and |
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6380
diff
changeset
|
174 |
(not Gear^.Hedgehog^.Effects[hePoisoned]) and |
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6380
diff
changeset
|
175 |
(not SuddenDeathDmg) then |
2017 | 176 |
Gear^.State:= Gear^.State or gstLoser; |
177 |
||
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
|
178 |
spawnHealthTagForHH(Gear, dmg); |
867 | 179 |
|
4365 | 180 |
RenderHealth(Gear^.Hedgehog^); |
181 |
RecountTeamHealth(Gear^.Hedgehog^.Team); |
|
1505 | 182 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
183 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
184 |
if (not isInMultiShoot) then Gear^.Karma:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
185 |
Gear^.Damage:= 0 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
186 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
187 |
Gear:= Gear^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
188 |
end; |
4 | 189 |
end; |
190 |
||
1054 | 191 |
procedure HealthMachine; |
192 |
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
|
193 |
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
|
194 |
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
|
195 |
flag: Boolean; |
3682 | 196 |
tmp: LongWord; |
1054 | 197 |
begin |
3682 | 198 |
Gear:= GearsList; |
1054 | 199 |
|
3682 | 200 |
while Gear <> nil do |
201 |
begin |
|
202 |
if Gear^.Kind = gtHedgehog then |
|
203 |
begin |
|
204 |
tmp:= 0; |
|
4365 | 205 |
if Gear^.Hedgehog^.Effects[hePoisoned] then |
4111 | 206 |
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
|
207 |
inc(tmp, ModifyDamage(5, Gear)); |
4365 | 208 |
if (GameFlags and gfResetHealth) <> 0 then dec(Gear^.Hedgehog^.InitialHealth) // does not need a minimum check since <= 1 basically disables it |
4111 | 209 |
end; |
4153
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
210 |
if (TotalRounds > cSuddenDTurns - 1) then |
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
211 |
begin |
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
212 |
inc(tmp, cHealthDecrease); |
4365 | 213 |
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
|
214 |
end; |
4365 | 215 |
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
|
216 |
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
|
217 |
flag:= false; |
4365 | 218 |
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
|
219 |
for i:= 0 to Pred(team^.HedgehogsNumber) do |
3697 | 220 |
if (team^.Hedgehogs[i].Gear <> nil) and |
221 |
(not team^.Hedgehogs[i].King) and |
|
222 |
(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
|
223 |
then flag:= true; |
4111 | 224 |
if not flag then |
225 |
begin |
|
226 |
inc(tmp, 5); |
|
4365 | 227 |
if (GameFlags and gfResetHealth) <> 0 then dec(Gear^.Hedgehog^.InitialHealth, 5) |
4111 | 228 |
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
|
229 |
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
|
230 |
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
|
231 |
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
|
232 |
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
|
233 |
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
|
234 |
end |
3682 | 235 |
end; |
1054 | 236 |
|
3682 | 237 |
Gear:= Gear^.NextGear |
238 |
end; |
|
1054 | 239 |
end; |
240 |
||
4 | 241 |
procedure ProcessGears; |
614 | 242 |
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
|
243 |
delay2: LongWord = 0; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
244 |
step: (stDelay, stChDmg, stSweep, stTurnReact, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
245 |
stAfterDelay, stChWin, stWater, stChWin2, stHealth, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
246 |
stSpawn, stNTurn) = stDelay; |
4 | 247 |
var Gear, t: PGear; |
4207
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
248 |
i, AliveCount: LongInt; |
3331 | 249 |
s: shortstring; |
4 | 250 |
begin |
868 | 251 |
PrvInactive:= AllInactive; |
4 | 252 |
AllInactive:= true; |
1495 | 253 |
|
2940 | 254 |
if (StepSoundTimer > 0) and (StepSoundChannel < 0) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
255 |
StepSoundChannel:= LoopSound(sndSteps) |
2940 | 256 |
else if (StepSoundTimer = 0) and (StepSoundChannel > -1) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
257 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
258 |
StopSound(StepSoundChannel); |
2993
d83edb74e92d
Remove animation on jumping/resuming walk, only leave it in on weapon switch
nemo
parents:
2991
diff
changeset
|
259 |
StepSoundChannel:= -1 |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
260 |
end; |
2940 | 261 |
|
262 |
if StepSoundTimer > 0 then |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
263 |
dec(StepSoundTimer, 1); |
2940 | 264 |
|
4 | 265 |
t:= GearsList; |
1054 | 266 |
while t <> nil do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
267 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
268 |
Gear:= t; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
269 |
t:= Gear^.NextGear; |
3123 | 270 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
271 |
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
|
272 |
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
|
273 |
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
|
274 |
begin |
6380
1ff5ad1d771b
Remove a bunch of unnecessary nil checks. FreeTexture does its own nil check.
nemo
parents:
6299
diff
changeset
|
275 |
FreeTexture(Gear^.Tex); |
2619 | 276 |
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
|
277 |
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
|
278 |
Gear^.doStep(Gear); |
3848 | 279 |
// might be useful later |
4492 | 280 |
//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
|
281 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
282 |
end; |
89 | 283 |
|
4 | 284 |
if AllInactive then |
1343 | 285 |
case step of |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
286 |
stDelay: begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
287 |
if delay = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
288 |
delay:= cInactDelay |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
289 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
290 |
dec(delay); |
614 | 291 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
292 |
if delay = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
293 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
294 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
295 |
stChDmg: if CheckNoDamage then inc(step) else step:= stDelay; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
296 |
stSweep: if SweepDirty then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
297 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
298 |
SetAllToActive; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
299 |
step:= stChDmg |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
300 |
end else inc(step); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
301 |
stTurnReact: begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
302 |
if (not bBetweenTurns) and (not isInMultiShoot) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
303 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
304 |
uStats.TurnReaction; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
305 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
306 |
end else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
307 |
inc(step, 2); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
308 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
309 |
stAfterDelay: begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
310 |
if delay = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
311 |
delay:= cInactDelay |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
312 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
313 |
dec(delay); |
815 | 314 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
315 |
if delay = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
316 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
317 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
318 |
stChWin: begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
319 |
CheckForWin; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
320 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
321 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
322 |
stWater: if (not bBetweenTurns) and (not isInMultiShoot) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
323 |
begin |
3331 | 324 |
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
|
325 |
|
4153
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
326 |
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
|
327 |
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
|
328 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
329 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
330 |
end else inc(step); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
331 |
stChWin2: begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
332 |
CheckForWin; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
333 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
334 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
335 |
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
|
336 |
if (cWaterRise <> 0) or (cHealthDecrease <> 0) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
337 |
begin |
6453
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6380
diff
changeset
|
338 |
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
|
339 |
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
|
340 |
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
|
341 |
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
|
342 |
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
|
343 |
SuddenDeathDmg:= true; |
5558
49cfd05ccb83
new SD flakes from mikade and a flash when sudden death starts
Henek
parents:
5556
diff
changeset
|
344 |
|
49cfd05ccb83
new SD flakes from mikade and a flash when sudden death starts
Henek
parents:
5556
diff
changeset
|
345 |
// flash |
49cfd05ccb83
new SD flakes from mikade and a flash when sudden death starts
Henek
parents:
5556
diff
changeset
|
346 |
ScreenFade:= sfFromWhite; |
49cfd05ccb83
new SD flakes from mikade and a flash when sudden death starts
Henek
parents:
5556
diff
changeset
|
347 |
ScreenFadeValue:= sfMax; |
49cfd05ccb83
new SD flakes from mikade and a flash when sudden death starts
Henek
parents:
5556
diff
changeset
|
348 |
ScreenFadeSpeed:= 1; |
49cfd05ccb83
new SD flakes from mikade and a flash when sudden death starts
Henek
parents:
5556
diff
changeset
|
349 |
|
4806
48c1a395f0a7
added flake configuration also in sudden death and SDClouds for underwater
Henek
parents:
4792
diff
changeset
|
350 |
ChangeToSDClouds; |
48c1a395f0a7
added flake configuration also in sudden death and SDClouds for underwater
Henek
parents:
4792
diff
changeset
|
351 |
ChangeToSDFlakes; |
5689
48ef34701751
Fix rounding error in sky colour causing visible lines
nemo
parents:
5681
diff
changeset
|
352 |
glClearColor(SDSkyColor.r * (SDTint/255) / 255, SDSkyColor.g * (SDTint/255) / 255, SDSkyColor.b * (SDTint/255) / 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
|
353 |
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
|
354 |
AddCaption(trmsg[sidSuddenDeath], cWhiteColor, capgrpGameState); |
4748 | 355 |
playSound(sndSuddenDeath); |
6472 | 356 |
StopMusic //No SDMusic for now |
357 |
//MusicFN:= SDMusic; |
|
358 |
//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
|
359 |
end |
6453
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6380
diff
changeset
|
360 |
else if (TotalRounds < cSuddenDTurns) 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
|
361 |
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
|
362 |
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
|
363 |
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
|
364 |
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
|
365 |
AddCaption(trmsg[sidRoundSD], cWhiteColor, capgrpGameState) |
6453
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6380
diff
changeset
|
366 |
else if (i = 2) or ((i > 0) and ((i mod 50 = 0) or ((i <= 25) and (i mod 5 = 0)))) 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
|
367 |
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
|
368 |
end; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
369 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
370 |
if bBetweenTurns |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
371 |
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
|
372 |
or (TotalRounds = -1) then inc(step) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
373 |
else begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
374 |
bBetweenTurns:= true; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
375 |
HealthMachine; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
376 |
step:= stChDmg |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
377 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
378 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
379 |
stSpawn: begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
380 |
if not isInMultiShoot then SpawnBoxOfSmth; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
381 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
382 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
383 |
stNTurn: begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
384 |
if isInMultiShoot then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
385 |
isInMultiShoot:= false |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
386 |
else begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
387 |
// delayed till after 0.9.12 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
388 |
// reset to default zoom |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
389 |
//ZoomValue:= ZoomDefault; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
390 |
with CurrentHedgehog^ do |
3697 | 391 |
if (Gear <> nil) |
2611 | 392 |
and ((Gear^.State and gstAttacked) = 0) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
393 |
and (MultiShootAttacks > 0) then OnUsedAmmo(CurrentHedgehog^); |
3697 | 394 |
|
3396
e5b3e5f2818e
More portal changes. Allows for a multishoot utility. Hopefully not breaking anything.
nemo
parents:
3390
diff
changeset
|
395 |
EndTurnCleanup; |
2376 | 396 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
397 |
FreeActionsList; // could send -left, -right and similar commands, so should be called before /nextturn |
1298 | 398 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
399 |
ParseCommand('/nextturn', true); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
400 |
SwitchHedgehog; |
1298 | 401 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
402 |
AfterSwitchHedgehog; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
403 |
bBetweenTurns:= false |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
404 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
405 |
step:= Low(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
406 |
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
|
407 |
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
|
408 |
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
|
409 |
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
|
410 |
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
|
411 |
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
|
412 |
else |
3957 | 413 |
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
|
414 |
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
|
415 |
|
6453
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6380
diff
changeset
|
416 |
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
|
417 |
begin |
5513
79dd457193e6
make a special case for teleport instead. also allows teleporting off of a parachute
nemo
parents:
5511
diff
changeset
|
418 |
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
|
419 |
begin |
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5501
diff
changeset
|
420 |
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
|
421 |
isCursorVisible := true |
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5501
diff
changeset
|
422 |
end; |
6453
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6380
diff
changeset
|
423 |
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
|
424 |
end; |
3957 | 425 |
if delay2 = 0 then |
426 |
begin |
|
5744 | 427 |
if (CurrentHedgehog^.Gear <> nil) and (CurrentHedgehog^.Gear^.State and gstAttacked = 0) and (CurAmmoGear = nil) then SweepDirty; |
3957 | 428 |
CheckNoDamage; |
4207
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
429 |
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
|
430 |
for i:= 0 to Pred(ClansCount) do |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
431 |
if ClansArray[i]^.ClanHealth > 0 then inc(AliveCount); |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
432 |
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
|
433 |
begin |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
434 |
step:= stChDmg; |
5016
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
5015
diff
changeset
|
435 |
if TagTurnTimeLeft = 0 then TagTurnTimeLeft:= TurnTimeLeft; |
4207
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
436 |
TurnTimeLeft:= 0 |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
437 |
end |
3957 | 438 |
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
|
439 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
440 |
end; |
15 | 441 |
|
4 | 442 |
if TurnTimeLeft > 0 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
443 |
if CurrentHedgehog^.Gear <> nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
444 |
if ((CurrentHedgehog^.Gear^.State and gstAttacking) = 0) |
6453
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6380
diff
changeset
|
445 |
and (not isInMultiShoot) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
446 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
447 |
if (TurnTimeLeft = 5000) |
4198 | 448 |
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
|
449 |
and (not PlacingHogs) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
450 |
and (CurrentHedgehog^.Gear <> nil) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
451 |
and ((CurrentHedgehog^.Gear^.State and gstAttacked) = 0) then |
5638
e35ba2a400d8
Try to avoid overlapping voices for major statements (not things like byebye or oof)
nemo
parents:
5622
diff
changeset
|
452 |
AddVoice(sndHurry, CurrentTeam^.voicepack); |
3799 | 453 |
if ReadyTimeLeft > 0 then |
454 |
begin |
|
455 |
if ReadyTimeLeft = 2000 then |
|
5638
e35ba2a400d8
Try to avoid overlapping voices for major statements (not things like byebye or oof)
nemo
parents:
5622
diff
changeset
|
456 |
AddVoice(sndComeonthen, CurrentTeam^.voicepack); |
3799 | 457 |
dec(ReadyTimeLeft) |
458 |
end |
|
459 |
else |
|
460 |
dec(TurnTimeLeft) |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
461 |
end; |
351 | 462 |
|
2621
956ff066f3a5
Fix desync when playing with AI via network, occuring in certain conditions
unc0rr
parents:
2619
diff
changeset
|
463 |
if skipFlag then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
464 |
begin |
5016
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
5015
diff
changeset
|
465 |
if TagTurnTimeLeft = 0 then TagTurnTimeLeft:= TurnTimeLeft; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
466 |
TurnTimeLeft:= 0; |
3784
75aa91bea32b
Extend statistics collection (TeamKills, TurnSkips, TeamDamage)
burp
parents:
3775
diff
changeset
|
467 |
skipFlag:= false; |
75aa91bea32b
Extend statistics collection (TeamKills, TurnSkips, TeamDamage)
burp
parents:
3775
diff
changeset
|
468 |
inc(CurrentHedgehog^.Team^.stats.TurnSkips); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
469 |
end; |
2621
956ff066f3a5
Fix desync when playing with AI via network, occuring in certain conditions
unc0rr
parents:
2619
diff
changeset
|
470 |
|
2134 | 471 |
if ((GameTicks and $FFFF) = $FFFF) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
472 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
473 |
if (not CurrentTeam^.ExtDriven) then |
5810 | 474 |
begin |
475 |
SendIPC('#'); |
|
476 |
AddFileLog('hiTicks increment message sent') |
|
477 |
end; |
|
2134 | 478 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
479 |
if (not CurrentTeam^.ExtDriven) or CurrentTeam^.hasGone then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
480 |
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
|
481 |
end; |
656
6d6d9d7b1054
Fix network game bug caused by recent protocol changes
unc0rr
parents:
651
diff
changeset
|
482 |
|
4417
6bf00d99fc47
move this call to where the game tick is actually incremented
nemo
parents:
4406
diff
changeset
|
483 |
ScriptCall('onGameTick'); |
515 | 484 |
inc(GameTicks) |
4 | 485 |
end; |
486 |
||
3396
e5b3e5f2818e
More portal changes. Allows for a multishoot utility. Hopefully not breaking anything.
nemo
parents:
3390
diff
changeset
|
487 |
//Purpose, to reset all transient attributes toggled by a utility and clean up various gears and effects at end of turn |
1854 | 488 |
//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
|
489 |
procedure EndTurnCleanup; |
1865
ebc6dfca60d4
- nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1863
diff
changeset
|
490 |
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
|
491 |
t: PGear; |
1849 | 492 |
begin |
2221 | 493 |
SpeechText:= ''; // in case it has not been consumed |
2017 | 494 |
|
1895 | 495 |
if (GameFlags and gfLowGravity) = 0 then |
4623 | 496 |
begin |
5872
454f246fe4c5
uh, that was just so I could look at the flame more closely, wasn't supposed to be checked in
nemo
parents:
5871
diff
changeset
|
497 |
cGravity:= cMaxWindSpeed * 2; |
4623 | 498 |
cGravityf:= 0.00025 * 2 |
499 |
end; |
|
1895 | 500 |
|
2017 | 501 |
if (GameFlags and gfVampiric) = 0 then |
502 |
cVampiric:= false; |
|
503 |
||
1849 | 504 |
cDamageModifier:= _1; |
1895 | 505 |
|
506 |
if (GameFlags and gfLaserSight) = 0 then |
|
507 |
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
|
508 |
|
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
509 |
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
|
510 |
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
|
511 |
// 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
|
512 |
if (CurrentTeam <> nil) then |
4099 | 513 |
with CurrentTeam^ do |
514 |
for i:= 0 to cMaxHHIndex do |
|
515 |
with Hedgehogs[i] do |
|
516 |
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
|
517 |
(* |
4099 | 518 |
if (SpeechGear <> nil) then |
519 |
begin |
|
520 |
DeleteVisualGear(SpeechGear); // remove to restore persisting beyond end of turn. Tiy says was too much of a gameplay issue |
|
521 |
SpeechGear:= nil |
|
522 |
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
|
523 |
*) |
2045
b0588498bc3a
- Fix network (my crappy fault, triggered by nemo's patch)
unc0rr
parents:
2042
diff
changeset
|
524 |
|
4099 | 525 |
if (Gear <> nil) then |
526 |
begin |
|
527 |
if (GameFlags and gfInvulnerable) = 0 then |
|
528 |
Gear^.Invulnerable:= false; |
|
529 |
end; |
|
530 |
end; |
|
3480
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
531 |
t:= GearsList; |
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
532 |
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
|
533 |
begin |
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
534 |
t^.PortalCounter:= 0; |
4372 | 535 |
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
|
536 |
begin |
4372 | 537 |
t^.Health:= t^.Hedgehog^.InitialHealth; |
538 |
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
|
539 |
end; |
3480
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
540 |
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
|
541 |
end; |
41e06b74c991
Enable resetting of weapons after each turn - useful in combination with a limited weaponset and unlimited attacks
nemo
parents:
3908
diff
changeset
|
542 |
|
6453
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6380
diff
changeset
|
543 |
if ((GameFlags and gfResetWeps) <> 0) and (not PlacingHogs) then |
4099 | 544 |
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
|
545 |
|
4099 | 546 |
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
|
547 |
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
|
548 |
RecountTeamHealth(TeamsArray[i]) |
1849 | 549 |
end; |
2045
b0588498bc3a
- Fix network (my crappy fault, triggered by nemo's patch)
unc0rr
parents:
2042
diff
changeset
|
550 |
|
4 | 551 |
procedure SetAllToActive; |
552 |
var t: PGear; |
|
553 |
begin |
|
554 |
AllInactive:= false; |
|
555 |
t:= GearsList; |
|
351 | 556 |
while t <> nil do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
557 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
558 |
t^.Active:= true; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
559 |
t:= t^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
560 |
end |
4 | 561 |
end; |
562 |
||
563 |
procedure SetAllHHToActive; |
|
564 |
var t: PGear; |
|
565 |
begin |
|
566 |
AllInactive:= false; |
|
567 |
t:= GearsList; |
|
351 | 568 |
while t <> nil do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
569 |
begin |
4813
53c2f0f92281
Make barrels drop when hog walks away from under it
unc0rr
parents:
4809
diff
changeset
|
570 |
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
|
571 |
t:= t^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
572 |
end |
4 | 573 |
end; |
574 |
||
4385 | 575 |
|
576 |
procedure DrawGears; |
|
577 |
var Gear: PGear; |
|
578 |
x, y: LongInt; |
|
2802 | 579 |
begin |
4385 | 580 |
Gear:= GearsList; |
581 |
while Gear <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
582 |
begin |
5348
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset
|
583 |
if Gear^.State and gstInvisible = 0 then |
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset
|
584 |
begin |
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset
|
585 |
x:= hwRound(Gear^.X) + WorldDx; |
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset
|
586 |
y:= hwRound(Gear^.Y) + WorldDy; |
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset
|
587 |
RenderGear(Gear, x, y); |
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset
|
588 |
end; |
4385 | 589 |
Gear:= Gear^.NextGear |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
590 |
end; |
2802 | 591 |
end; |
592 |
||
4 | 593 |
procedure FreeGearsList; |
594 |
var t, tt: PGear; |
|
595 |
begin |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
596 |
tt:= GearsList; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
597 |
GearsList:= nil; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
598 |
while tt <> nil do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
599 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
600 |
t:= tt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
601 |
tt:= tt^.NextGear; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
602 |
Dispose(t) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
603 |
end; |
4 | 604 |
end; |
605 |
||
10 | 606 |
procedure AddMiscGears; |
5179
8d64dcb566ea
Fix "Mixing signed expressions and longwords gives a 64bit result" warnings
unc0rr
parents:
5139
diff
changeset
|
607 |
var i: Longword; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
608 |
Gear: PGear; |
4 | 609 |
begin |
498 | 610 |
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
|
611 |
|
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
|
612 |
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
|
613 |
Gear:= PGear(1); |
4834 | 614 |
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
|
615 |
begin |
4148
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
616 |
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
|
617 |
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
|
618 |
inc(i) |
4148
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
619 |
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
|
620 |
|
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
|
621 |
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
|
622 |
Gear:= PGear(1); |
4833 | 623 |
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
|
624 |
begin |
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
625 |
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
|
626 |
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
|
627 |
inc(i) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
628 |
end; |
1895 | 629 |
|
630 |
if (GameFlags and gfLowGravity) <> 0 then |
|
4623 | 631 |
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
|
632 |
cGravity:= cMaxWindSpeed; |
4623 | 633 |
cGravityf:= 0.00025 |
634 |
end; |
|
1895 | 635 |
|
2017 | 636 |
if (GameFlags and gfVampiric) <> 0 then |
637 |
cVampiric:= true; |
|
638 |
||
1895 | 639 |
Gear:= GearsList; |
640 |
if (GameFlags and gfInvulnerable) <> 0 then |
|
641 |
while Gear <> nil do |
|
642 |
begin |
|
643 |
Gear^.Invulnerable:= true; // this is only checked on hogs right now, so no need for gear type check |
|
644 |
Gear:= Gear^.NextGear |
|
645 |
end; |
|
646 |
||
647 |
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
|
648 |
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
|
649 |
|
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
650 |
if (GameFlags and gfArtillery) <> 0 then |
4611 | 651 |
cArtillery:= true; |
652 |
||
5015 | 653 |
if not hasBorder and ((Theme = 'Snow') or (Theme = 'Christmas')) then |
4621 | 654 |
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
|
655 |
AddGear(GetRandom(LAND_WIDTH+1024)-512, LAND_HEIGHT - GetRandom(LAND_HEIGHT div 2), gtFlake, 0, _0, _0, 0); |
4 | 656 |
end; |
657 |
||
4837
2ea0a152c319
Pass PHedgehog instead of PGear to stats. Fixes crash.
unc0rr
parents:
4835
diff
changeset
|
658 |
procedure doMakeExplosion(X, Y, Radius: LongInt; AttackingHog: PHedgehog; Mask: Longword; const Tint: LongWord); |
4 | 659 |
var Gear: PGear; |
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
660 |
dmg, dmgRadius, dmgBase: LongInt; |
3322 | 661 |
fX, fY: hwFloat; |
3475 | 662 |
vg: PVisualGear; |
3689 | 663 |
i, cnt: LongInt; |
4 | 664 |
begin |
4900 | 665 |
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
|
666 |
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
|
667 |
|
3032 | 668 |
if ((Mask and EXPLNoGfx) = 0) then |
669 |
begin |
|
3475 | 670 |
vg:= nil; |
671 |
if Radius > 50 then vg:= AddVisualGear(X, Y, vgtBigExplosion) |
|
672 |
else if Radius > 10 then vg:= AddVisualGear(X, Y, vgtExplosion); |
|
673 |
if vg <> nil then |
|
674 |
vg^.Tint:= Tint; |
|
3032 | 675 |
end; |
2745 | 676 |
if (Mask and EXPLAutoSound) <> 0 then PlaySound(sndExplosion); |
1433 | 677 |
|
678 |
if (Mask and EXPLAllDamageInRadius) = 0 then |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
679 |
dmgRadius:= Radius shl 1 |
1433 | 680 |
else |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
681 |
dmgRadius:= Radius; |
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
682 |
dmgBase:= dmgRadius + cHHRadius div 2; |
3322 | 683 |
fX:= int2hwFloat(X); |
684 |
fY:= int2hwFloat(Y); |
|
4 | 685 |
Gear:= GearsList; |
686 |
while Gear <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
687 |
begin |
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
688 |
dmg:= 0; |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
689 |
//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
|
690 |
//if (dmg > 1) and |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
691 |
if (Gear^.State and gstNoDamage) = 0 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
692 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
693 |
case Gear^.Kind of |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
694 |
gtHedgehog, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
695 |
gtMine, |
6119
91792f506371
Make a few more things be impacted by explosions nearby
nemo
parents:
6096
diff
changeset
|
696 |
gtBall, |
91792f506371
Make a few more things be impacted by explosions nearby
nemo
parents:
6096
diff
changeset
|
697 |
gtMelonPiece, |
91792f506371
Make a few more things be impacted by explosions nearby
nemo
parents:
6096
diff
changeset
|
698 |
gtGrenade, |
91792f506371
Make a few more things be impacted by explosions nearby
nemo
parents:
6096
diff
changeset
|
699 |
gtClusterBomb, |
6298 | 700 |
// gtCluster, too game breaking I think |
3710 | 701 |
gtSMine, |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
702 |
gtCase, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
703 |
gtTarget, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
704 |
gtFlame, |
4881
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4867
diff
changeset
|
705 |
gtExplosives, |
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4867
diff
changeset
|
706 |
gtStructure: begin |
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
707 |
// Run the calcs only once we know we have a type that will need damage |
3322 | 708 |
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
|
709 |
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
|
710 |
if dmg > 1 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
711 |
begin |
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
712 |
dmg:= ModifyDamage(min(dmg div 2, Radius), Gear); |
4900 | 713 |
//AddFileLog('Damage: ' + inttostr(dmg)); |
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
714 |
if (Mask and EXPLNoDamage) = 0 then |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
715 |
begin |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
716 |
if not Gear^.Invulnerable then |
4837
2ea0a152c319
Pass PHedgehog instead of PGear to stats. Fixes crash.
unc0rr
parents:
4835
diff
changeset
|
717 |
ApplyDamage(Gear, AttackingHog, dmg, dsExplosion) |
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
718 |
else |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
719 |
Gear^.State:= Gear^.State or gstWinner; |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
720 |
end; |
3712 | 721 |
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
|
722 |
begin |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
723 |
DeleteCI(Gear); |
6299 | 724 |
if Gear^.Kind <> gtHedgehog then |
725 |
begin |
|
726 |
Gear^.dX:= Gear^.dX + SignAs(_0_005 * dmg + cHHKick, Gear^.X - fX)/Gear^.Density; |
|
727 |
Gear^.dY:= Gear^.dY + SignAs(_0_005 * dmg + cHHKick, Gear^.Y - fY)/Gear^.Density; |
|
728 |
end |
|
729 |
else |
|
730 |
begin |
|
731 |
Gear^.dX:= Gear^.dX + SignAs(_0_005 * dmg + cHHKick, Gear^.X - fX); |
|
732 |
Gear^.dY:= Gear^.dY + SignAs(_0_005 * dmg + cHHKick, Gear^.Y - fY); |
|
733 |
end; |
|
734 |
||
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
735 |
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
|
736 |
if not Gear^.Invulnerable then |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
737 |
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
|
738 |
Gear^.Active:= true; |
3997 | 739 |
if Gear^.Kind <> gtFlame then FollowGear:= Gear |
3112 | 740 |
end; |
6453
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6380
diff
changeset
|
741 |
if ((Mask and EXPLPoisoned) <> 0) and (Gear^.Kind = gtHedgehog) and (not Gear^.Invulnerable) then |
4365 | 742 |
Gear^.Hedgehog^.Effects[hePoisoned] := true; |
3112 | 743 |
end; |
3100 | 744 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
745 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
746 |
gtGrave: begin |
3097
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
747 |
// Run the calcs only once we know we have a type that will need damage |
3322 | 748 |
if hwRound(hwAbs(Gear^.X-fX)+hwAbs(Gear^.Y-fY)) < dmgBase then |
749 |
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
|
750 |
if dmg > 1 then |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
751 |
begin |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
752 |
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
|
753 |
Gear^.dY:= - _0_004 * dmg; |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
754 |
Gear^.Active:= true |
6fa39c1c41b9
Try to reduce expensive Distance() call until sure it is needed
nemo
parents:
3094
diff
changeset
|
755 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
756 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
757 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
758 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
759 |
Gear:= Gear^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
760 |
end; |
1200 | 761 |
|
621 | 762 |
if (Mask and EXPLDontDraw) = 0 then |
3689 | 763 |
if (GameFlags and gfSolidLand) = 0 then |
764 |
begin |
|
765 |
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
|
766 |
if (cnt > 0) and (SpritesData[sprChunk].Texture <> nil) then |
3689 | 767 |
for i:= 0 to cnt do |
768 |
AddVisualGear(X, Y, vgtChunk) |
|
769 |
end; |
|
1200 | 770 |
|
498 | 771 |
uAIMisc.AwareOfExplosion(0, 0, 0) |
4 | 772 |
end; |
773 |
||
506 | 774 |
procedure ShotgunShot(Gear: PGear); |
775 |
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
|
776 |
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
|
777 |
dx, dy: hwFloat; |
506 | 778 |
begin |
509 | 779 |
Gear^.Radius:= cShotgunRadius; |
506 | 780 |
t:= GearsList; |
781 |
while t <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
782 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
783 |
case t^.Kind of |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
784 |
gtHedgehog, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
785 |
gtMine, |
3710 | 786 |
gtSMine, |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
787 |
gtCase, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
788 |
gtTarget, |
4881
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4867
diff
changeset
|
789 |
gtExplosives, |
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4867
diff
changeset
|
790 |
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
|
791 |
//addFileLog('ShotgunShot radius: ' + inttostr(Gear^.Radius) + ', t^.Radius = ' + inttostr(t^.Radius) + ', distance = ' + inttostr(dist) + ', dmg = ' + inttostr(dmg)); |
5590 | 792 |
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
|
793 |
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
|
794 |
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
|
795 |
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
|
796 |
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
|
797 |
dy.isNegative:= false; |
5590 | 798 |
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
|
799 |
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
|
800 |
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
|
801 |
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
|
802 |
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
|
803 |
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
|
804 |
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
|
805 |
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
|
806 |
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
|
807 |
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
|
808 |
Gear^.State:= Gear^.State or gstWinner; |
867 | 809 |
|
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
|
810 |
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
|
811 |
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
|
812 |
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
|
813 |
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
|
814 |
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
|
815 |
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
|
816 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
817 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
818 |
gtGrave: begin |
5590 | 819 |
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
|
820 |
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
|
821 |
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
|
822 |
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
|
823 |
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
|
824 |
dy.isNegative:= false; |
5590 | 825 |
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
|
826 |
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
|
827 |
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
|
828 |
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
|
829 |
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
|
830 |
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
|
831 |
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
|
832 |
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
|
833 |
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
|
834 |
end |
2948
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 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
837 |
t:= t^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
838 |
end; |
621 | 839 |
if (GameFlags and gfSolidLand) = 0 then DrawExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), cShotgunRadius) |
506 | 840 |
end; |
841 |
||
371 | 842 |
procedure AmmoShove(Ammo: PGear; Damage, Power: LongInt); |
53 | 843 |
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
|
844 |
Gear: PGear; |
2726 | 845 |
i, tmpDmg: LongInt; |
4327 | 846 |
VGear: PVisualGear; |
38 | 847 |
begin |
53 | 848 |
t:= CheckGearsCollision(Ammo); |
3098
e5a1bc4e56fd
Specifically check for current hedgehog being on rope, the tricky bastard.
nemo
parents:
3097
diff
changeset
|
849 |
// Just to avoid hogs on rope dodging fire. |
5622 | 850 |
if (CurAmmoGear <> nil) and ((CurAmmoGear^.Kind = gtRope) or (CurAmmoGear^.Kind = gtJetpack) or (CurAmmoGear^.Kind = gtBirdy)) and |
3697 | 851 |
(CurrentHedgehog^.Gear <> nil) and (CurrentHedgehog^.Gear^.CollisionIndex = -1) and |
852 |
(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
|
853 |
begin |
e5a1bc4e56fd
Specifically check for current hedgehog being on rope, the tricky bastard.
nemo
parents:
3097
diff
changeset
|
854 |
t^.ar[t^.Count]:= CurrentHedgehog^.Gear; |
e5a1bc4e56fd
Specifically check for current hedgehog being on rope, the tricky bastard.
nemo
parents:
3097
diff
changeset
|
855 |
inc(t^.Count) |
4182 | 856 |
end; |
4165 | 857 |
|
351 | 858 |
i:= t^.Count; |
1506 | 859 |
|
2489 | 860 |
if (Ammo^.Kind = gtFlame) and (i > 0) then Ammo^.Health:= 0; |
53 | 861 |
while i > 0 do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
862 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
863 |
dec(i); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
864 |
Gear:= t^.ar[i]; |
2726 | 865 |
tmpDmg:= ModifyDamage(Damage, Gear); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
866 |
if (Gear^.State and gstNoDamage) = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
867 |
begin |
4824 | 868 |
|
4329 | 869 |
if (Ammo^.Kind = gtDEagleShot) or (Ammo^.Kind = gtSniperRifleShot) then |
4578 | 870 |
begin |
4329 | 871 |
VGear := AddVisualGear(hwround(Ammo^.X), hwround(Ammo^.Y), vgtBulletHit); |
4578 | 872 |
if VGear <> nil then VGear^.Angle := DxDy2Angle(-Ammo^.dX, Ammo^.dY); |
4329 | 873 |
end; |
4824 | 874 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
875 |
if (Gear^.Kind = gtHedgehog) and (Ammo^.State and gsttmpFlag <> 0) and (Ammo^.Kind = gtShover) then Gear^.FlightTime:= 1; |
3697 | 876 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
877 |
case Gear^.Kind of |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
878 |
gtHedgehog, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
879 |
gtMine, |
3710 | 880 |
gtSMine, |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
881 |
gtTarget, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
882 |
gtCase, |
4881
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4867
diff
changeset
|
883 |
gtExplosives, |
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4867
diff
changeset
|
884 |
gtStructure: begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
885 |
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
|
886 |
if (not Gear^.Invulnerable) then |
4837
2ea0a152c319
Pass PHedgehog instead of PGear to stats. Fixes crash.
unc0rr
parents:
4835
diff
changeset
|
887 |
ApplyDamage(Gear, Ammo^.Hedgehog, tmpDmg, dsShove) |
1865
ebc6dfca60d4
- nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1863
diff
changeset
|
888 |
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
|
889 |
Gear^.State:= Gear^.State or gstWinner; |
5706 | 890 |
if (Gear^.Kind = gtExplosives) and (Ammo^.Kind = gtBlowtorch) then |
891 |
begin |
|
6453
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6380
diff
changeset
|
892 |
if (Ammo^.Hedgehog^.Gear <> nil) then Ammo^.Hedgehog^.Gear^.State:= Ammo^.Hedgehog^.Gear^.State and (not gstNotKickable); |
5706 | 893 |
ApplyDamage(Gear, Ammo^.Hedgehog, tmpDmg * 100, dsUnknown); // crank up damage for explosives + blowtorch |
894 |
end; |
|
867 | 895 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
896 |
DeleteCI(Gear); |
4365 | 897 |
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
|
898 |
begin |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
899 |
Gear^.dX:= Ammo^.dX * Power * _0_005; |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
900 |
Gear^.dY:= Ammo^.dY * Power * _0_005 |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
901 |
end |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
902 |
else |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
903 |
begin |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
904 |
Gear^.dX:= Ammo^.dX * Power * _0_01; |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
905 |
Gear^.dY:= Ammo^.dY * Power * _0_01 |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
906 |
end; |
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset
|
907 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
908 |
Gear^.Active:= true; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
909 |
Gear^.State:= Gear^.State or gstMoving; |
867 | 910 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
911 |
if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
912 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
913 |
if not (TestCollisionXwithXYShift(Gear, _0, -3, hwSign(Gear^.dX)) |
6081
537bbd5c1a62
Basic test implementation of an ice flag. Allows for slick parts of terrain. Intended for ice gun, or "ice" mask on portions of land objects.
nemo
parents:
5977
diff
changeset
|
914 |
or (TestCollisionYwithGear(Gear, -1) <> 0)) then Gear^.Y:= Gear^.Y - _1; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
915 |
if not (TestCollisionXwithXYShift(Gear, _0, -2, hwSign(Gear^.dX)) |
6081
537bbd5c1a62
Basic test implementation of an ice flag. Allows for slick parts of terrain. Intended for ice gun, or "ice" mask on portions of land objects.
nemo
parents:
5977
diff
changeset
|
916 |
or (TestCollisionYwithGear(Gear, -1) <> 0)) then Gear^.Y:= Gear^.Y - _1; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
917 |
if not (TestCollisionXwithXYShift(Gear, _0, -1, hwSign(Gear^.dX)) |
6081
537bbd5c1a62
Basic test implementation of an ice flag. Allows for slick parts of terrain. Intended for ice gun, or "ice" mask on portions of land objects.
nemo
parents:
5977
diff
changeset
|
918 |
or (TestCollisionYwithGear(Gear, -1) <> 0)) then Gear^.Y:= Gear^.Y - _1; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
919 |
end; |
3697 | 920 |
|
2537
aceebf0653f7
Disable followgear on ammoshove for napalm fire damage
nemo
parents:
2492
diff
changeset
|
921 |
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
|
922 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
923 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
924 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
925 |
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
|
926 |
if i <> 0 then SetAllToActive |
38 | 927 |
end; |
928 |
||
4 | 929 |
procedure AssignHHCoords; |
955 | 930 |
var i, t, p, j: LongInt; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
931 |
ar: array[0..Pred(cMaxHHs)] of PHedgehog; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
932 |
Count: Longword; |
4 | 933 |
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
|
934 |
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
|
935 |
if (GameFlags and gfDivideTeams) <> 0 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
936 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
937 |
t:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
938 |
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
|
939 |
for p:= 0 to 1 do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
940 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
941 |
with ClansArray[p]^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
942 |
for j:= 0 to Pred(TeamsNumber) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
943 |
with Teams[j]^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
944 |
for i:= 0 to cMaxHHIndex do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
945 |
with Hedgehogs[i] do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
946 |
if (Gear <> nil) and (Gear^.X.QWordValue = 0) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
947 |
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
|
948 |
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
|
949 |
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
|
950 |
if Gear <> nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
951 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
952 |
Gear^.Pos:= GetRandom(49); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
953 |
Gear^.dX.isNegative:= p = 1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
954 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
955 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
956 |
t:= LAND_WIDTH div 2 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
957 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
958 |
end else // mix hedgehogs |
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 |
Count:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
961 |
for p:= 0 to Pred(TeamsCount) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
962 |
with TeamsArray[p]^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
963 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
964 |
for i:= 0 to cMaxHHIndex do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
965 |
with Hedgehogs[i] do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
966 |
if (Gear <> nil) and (Gear^.X.QWordValue = 0) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
967 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
968 |
ar[Count]:= @Hedgehogs[i]; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
969 |
inc(Count) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
970 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
971 |
end; |
1792 | 972 |
// unC0Rr, while it is true user can watch value on map screen, IMO this (and check above) should be enforced in UI |
973 |
// - is there a good place to put values for the different widgets to check? Right now they are kind of disconnected. |
|
1965 | 974 |
//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
|
975 |
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
|
976 |
while (Count > 0) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
977 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
978 |
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
|
979 |
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
|
980 |
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
|
981 |
if ar[i]^.Gear <> nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
982 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
983 |
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
|
984 |
ar[i]^.Gear^.Pos:= GetRandom(19) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
985 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
986 |
ar[i]:= ar[Count - 1]; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
987 |
dec(Count) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
988 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
989 |
end |
4 | 990 |
end; |
991 |
||
4024
1ffb84b3823d
Resurrector: respect modified Gear position for resurrection range circle
Tobias Neumann <mail@tobias-neumann.eu>
parents:
4007
diff
changeset
|
992 |
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
|
993 |
var |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
994 |
t: PGear; |
5556 | 995 |
l: Longword; |
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
996 |
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
|
997 |
r:= r*r; |
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
998 |
GearsNear := nil; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
999 |
t := GearsList; |
5556 | 1000 |
while t <> nil do |
1001 |
begin |
|
1002 |
if (t^.Kind = Kind) |
|
1003 |
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
|
1004 |
begin |
5556 | 1005 |
l:= Length(GearsNear); |
1006 |
SetLength(GearsNear, l + 1); |
|
1007 |
GearsNear[l] := t; |
|
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1008 |
end; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1009 |
t := t^.NextGear; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1010 |
end; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1011 |
end; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
1012 |
|
1433 | 1013 |
{procedure AmmoFlameWork(Ammo: PGear); |
79 | 1014 |
var t: PGear; |
1015 |
begin |
|
1016 |
t:= GearsList; |
|
1017 |
while t <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1018 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1019 |
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
|
1020 |
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
|
1021 |
begin |
2017 | 1022 |
ApplyDamage(t, 5); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1023 |
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
|
1024 |
t^.dY:= - _0_25; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1025 |
t^.Active:= true; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1026 |
DeleteCI(t); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1027 |
FollowGear:= t |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1028 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1029 |
t:= t^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1030 |
end; |
1433 | 1031 |
end;} |
79 | 1032 |
|
16 | 1033 |
|
1034 |
function CountGears(Kind: TGearType): Longword; |
|
1035 |
var t: PGear; |
|
2695 | 1036 |
count: Longword = 0; |
16 | 1037 |
begin |
2695 | 1038 |
|
16 | 1039 |
t:= GearsList; |
1040 |
while t <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1041 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1042 |
if t^.Kind = Kind then inc(count); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1043 |
t:= t^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1044 |
end; |
2695 | 1045 |
CountGears:= count; |
16 | 1046 |
end; |
1047 |
||
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
|
1048 |
function SpawnCustomCrateAt(x, y: LongInt; crate: TCrateType; content: Longword): PGear; |
3730 | 1049 |
begin |
3734 | 1050 |
FollowGear := AddGear(x, y, gtCase, 0, _0, _0, 0); |
1051 |
cCaseFactor := 0; |
|
1052 |
||
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
|
1053 |
if (crate <> HealthCrate) and (content > ord(High(TAmmoType))) then content := ord(High(TAmmoType)); |
3734 | 1054 |
|
1055 |
case crate of |
|
1056 |
HealthCrate: begin |
|
1057 |
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
|
1058 |
FollowGear^.Health := content; |
3734 | 1059 |
AddCaption(GetEventString(eidNewHealthPack), cWhiteColor, capgrpAmmoInfo); |
1060 |
end; |
|
1061 |
AmmoCrate: begin |
|
1062 |
FollowGear^.Pos := posCaseAmmo; |
|
4240
4e81670e52aa
er. and cast to TAmmoType, which burp's routine still requires :)
nemo
parents:
4239
diff
changeset
|
1063 |
FollowGear^.AmmoType := TAmmoType(content); |
3734 | 1064 |
AddCaption(GetEventString(eidNewAmmoPack), cWhiteColor, capgrpAmmoInfo); |
1065 |
end; |
|
1066 |
UtilityCrate: begin |
|
1067 |
FollowGear^.Pos := posCaseUtility; |
|
4240
4e81670e52aa
er. and cast to TAmmoType, which burp's routine still requires :)
nemo
parents:
4239
diff
changeset
|
1068 |
FollowGear^.AmmoType := TAmmoType(content); |
3734 | 1069 |
AddCaption(GetEventString(eidNewUtilityPack), cWhiteColor, capgrpAmmoInfo); |
1070 |
end; |
|
1071 |
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
|
1072 |
|
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
|
1073 |
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
|
1074 |
|
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
|
1075 |
SpawnCustomCrateAt := FollowGear; |
3730 | 1076 |
end; |
1077 |
||
5343 | 1078 |
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
|
1079 |
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
|
1080 |
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
|
1081 |
cCaseFactor := 0; |
5343 | 1082 |
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
|
1083 |
|
5343 | 1084 |
if explode then FollowGear^.Pos := FollowGear^.Pos + posCaseExplode; |
1085 |
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
|
1086 |
|
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
|
1087 |
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
|
1088 |
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
|
1089 |
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
|
1090 |
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
|
1091 |
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
|
1092 |
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
|
1093 |
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
|
1094 |
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
|
1095 |
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
|
1096 |
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
|
1097 |
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
|
1098 |
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
|
1099 |
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
|
1100 |
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
|
1101 |
|
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
|
1102 |
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
|
1103 |
|
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
|
1104 |
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
|
1105 |
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
|
1106 |
|
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
|
1107 |
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
|
1108 |
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
|
1109 |
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
|
1110 |
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
|
1111 |
|
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
|
1112 |
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
|
1113 |
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
|
1114 |
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
|
1115 |
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
|
1116 |
|
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
|
1117 |
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
|
1118 |
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
|
1119 |
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
|
1120 |
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
|
1121 |
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
|
1122 |
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
|
1123 |
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
|
1124 |
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
|
1125 |
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
|
1126 |
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
|
1127 |
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
|
1128 |
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
|
1129 |
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
|
1130 |
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
|
1131 |
|
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
|
1132 |
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
|
1133 |
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
|
1134 |
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
|
1135 |
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
|
1136 |
|
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
|
1137 |
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
|
1138 |
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
|
1139 |
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
|
1140 |
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
|
1141 |
|
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
|
1142 |
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
|
1143 |
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
|
1144 |
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
|
1145 |
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
|
1146 |
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
|
1147 |
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
|
1148 |
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
|
1149 |
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
|
1150 |
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
|
1151 |
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
|
1152 |
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
|
1153 |
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
|
1154 |
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
|
1155 |
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
|
1156 |
|
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
|
1157 |
|
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
|
1158 |
|
15 | 1159 |
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
|
1160 |
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
|
1161 |
i: TAmmoType; |
15 | 1162 |
begin |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2760
diff
changeset
|
1163 |
if (PlacingHogs) or |
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2760
diff
changeset
|
1164 |
(cCaseFactor = 0) or |
614 | 1165 |
(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
|
1166 |
(GetRandom(cCaseFactor) <> 0) then exit; |
1295 | 1167 |
|
1948 | 1168 |
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
|
1169 |
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
|
1170 |
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
|
1171 |
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
|
1172 |
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
|
1173 |
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
|
1174 |
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
|
1175 |
inc(uTot, Ammoz[i].Probability); |
1966 | 1176 |
|
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
|
1177 |
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
|
1178 |
a:=aTot; |
3268 | 1179 |
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
|
1180 |
|
3268 | 1181 |
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
|
1182 |
if ((GameFlags and gfInvulnerable) = 0) then |
3268 | 1183 |
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
|
1184 |
h:= cHealthCaseProb * 100; |
3268 | 1185 |
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
|
1186 |
a:= (10000-h)*aTot div (aTot+uTot) |
3268 | 1187 |
end |
3697 | 1188 |
else |
3268 | 1189 |
begin |
1190 |
t:= GetRandom(aTot+uTot); |
|
1191 |
h:= 0 |
|
1192 |
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
|
1193 |
|
3697 | 1194 |
|
3261
fa7086253e83
Rebalance Default to take into account reweighting of crates, remove redundant check
nemo
parents:
3259
diff
changeset
|
1195 |
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
|
1196 |
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
|
1197 |
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
|
1198 |
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
|
1199 |
FollowGear^.Pos:= posCaseHealth; |
3331 | 1200 |
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
|
1201 |
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
|
1202 |
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
|
1203 |
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
|
1204 |
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
|
1205 |
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
|
1206 |
begin |
1865
ebc6dfca60d4
- nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1863
diff
changeset
|
1207 |
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
|
1208 |
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
|
1209 |
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
|
1210 |
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
|
1211 |
FollowGear^.AmmoType:= i; |
3331 | 1212 |
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
|
1213 |
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
|
1214 |
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
|
1215 |
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
|
1216 |
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
|
1217 |
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
|
1218 |
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
|
1219 |
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
|
1220 |
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
|
1221 |
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
|
1222 |
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
|
1223 |
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
|
1224 |
FollowGear^.AmmoType:= i; |
3331 | 1225 |
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
|
1226 |
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
|
1227 |
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
|
1228 |
|
1865
ebc6dfca60d4
- nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1863
diff
changeset
|
1229 |
// 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
|
1230 |
if (FollowGear <> nil) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1231 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1232 |
FindPlace(FollowGear, true, 0, LAND_WIDTH); |
2376 | 1233 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1234 |
if (FollowGear <> nil) then |
5638
e35ba2a400d8
Try to avoid overlapping voices for major statements (not things like byebye or oof)
nemo
parents:
5622
diff
changeset
|
1235 |
AddVoice(sndReinforce, CurrentTeam^.voicepack) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1236 |
end |
70 | 1237 |
end; |
1238 |
||
2726 | 1239 |
|
2790 | 1240 |
function GearByUID(uid : Longword) : PGear; |
1241 |
var gear: PGear; |
|
1242 |
begin |
|
1243 |
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
|
1244 |
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
|
1245 |
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
|
1246 |
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
|
1247 |
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
|
1248 |
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
|
1249 |
end; |
2790 | 1250 |
gear:= GearsList; |
1251 |
while gear <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1252 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1253 |
if gear^.uid = uid then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1254 |
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
|
1255 |
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
|
1256 |
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
|
1257 |
exit |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1258 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1259 |
gear:= gear^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1260 |
end |
2790 | 1261 |
end; |
1262 |
||
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
|
1263 |
|
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
|
1264 |
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
|
1265 |
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
|
1266 |
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
|
1267 |
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
|
1268 |
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
|
1269 |
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
|
1270 |
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
|
1271 |
|
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
|
1272 |
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
|
1273 |
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
|
1274 |
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
|
1275 |
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
|
1276 |
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
|
1277 |
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
|
1278 |
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
|
1279 |
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
|
1280 |
i:= 0; |
4469 | 1281 |
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
|
1282 |
x:= byte(s[1]); // speech type |
4469 | 1283 |
if x < 4 then |
1284 |
begin |
|
1285 |
t:= byte(s[2]); // team |
|
1286 |
if Length(s) > 2 then h:= byte(s[3]) // target hog |
|
1287 |
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
|
1288 |
// allow targetting a hog by specifying a number as the first portion of the text |
4468 | 1289 |
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
|
1290 |
if i <> 0 then text:= copy(s, 4, Length(s) - 1) |
4468 | 1291 |
else if x < 4 then text:= copy(s, 3, Length(s) - 1) |
1292 |
else text:= copy(s, 2, Length(s) - 1); |
|
1293 |
||
4470
d2b8d2fc51a9
disable say, just don't do anything. trying to avoid spew on spectator join
nemo
parents:
4469
diff
changeset
|
1294 |
(* |
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
|
1295 |
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
|
1296 |
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
|
1297 |
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
|
1298 |
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
|
1299 |
end; |
4470
d2b8d2fc51a9
disable say, just don't do anything. trying to avoid spew on spectator join
nemo
parents:
4469
diff
changeset
|
1300 |
*) |
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
|
1301 |
|
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
|
1302 |
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
|
1303 |
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
|
1304 |
// if team matches current hedgehog team, default to current hedgehog |
4783 | 1305 |
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
|
1306 |
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
|
1307 |
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
|
1308 |
// 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
|
1309 |
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
|
1310 |
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
|
1311 |
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
|
1312 |
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
|
1313 |
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
|
1314 |
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
|
1315 |
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
|
1316 |
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
|
1317 |
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
|
1318 |
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
|
1319 |
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
|
1320 |
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
|
1321 |
end; |
4784 | 1322 |
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
|
1323 |
begin |
4784 | 1324 |
Gear:= AddVisualGear(0, 0, vgtSpeechBubble); |
1325 |
if Gear <> nil then |
|
1326 |
begin |
|
1327 |
Gear^.Hedgehog:= hh; |
|
1328 |
Gear^.Text:= text; |
|
1329 |
Gear^.FrameTicks:= x |
|
1330 |
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
|
1331 |
end |
4706 | 1332 |
//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
|
1333 |
end |
4470
d2b8d2fc51a9
disable say, just don't do anything. trying to avoid spew on spectator join
nemo
parents:
4469
diff
changeset
|
1334 |
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
|
1335 |
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
|
1336 |
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
|
1337 |
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
|
1338 |
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
|
1339 |
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
|
1340 |
|
3038 | 1341 |
procedure initModule; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
1342 |
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
|
1343 |
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
|
1344 |
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
|
1345 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1346 |
CurAmmoGear:= nil; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1347 |
GearsList:= nil; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1348 |
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
|
1349 |
SuddenDeath:= false; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1350 |
SuddenDeathDmg:= false; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1351 |
SpeechType:= 1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1352 |
skipFlag:= false; |
3697 | 1353 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1354 |
AllInactive:= false; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1355 |
PrvInactive:= false; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
1356 |
end; |
4 | 1357 |
|
3038 | 1358 |
procedure freeModule; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
1359 |
begin |
3615 | 1360 |
FreeGearsList(); |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
1361 |
end; |
4 | 1362 |
|
2451
5affd0840927
New data files from Tiy, add gtFlame to avoidance list
nemo
parents:
2428
diff
changeset
|
1363 |
end. |