author  lovelacer 
Tue, 17 Jan 2012 09:01:31 0500  
changeset 6580  6155187bf599 
parent 6543  697e9b730189 
child 6596  4c06ea12de1c 
permissions  rwrr 
4  1 
(* 
1066  2 
* Hedgewars, a free turn based strategy game 
4976  3 
* Copyright (c) 20042011 Andrey Korotaev <unC0Rr@gmail.com> 
4  4 
* 
183  5 
* This program is free software; you can redistribute it and/or modify 
6 
* it under the terms of the GNU General Public License as published by 

7 
* the Free Software Foundation; version 2 of the License 

4  8 
* 
183  9 
* This program is distributed in the hope that it will be useful, 
10 
* but WITHOUT ANY WARRANTY; without even the implied warranty of 

11 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 

12 
* GNU General Public License for more details. 

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

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

4  17 
*) 
18 

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; 
6515
74a04089bb56
Suggestion of sheepluva's  disable timebox in crates after SD, and set to disabled in Ammo. Also disable switch hedgehog for teams of 1 hedgehog in size, and try and correct what appears to be a bug in reserved hats.
nemo
parents:
6472
diff
changeset

42 
function GetAmmo(Hedgehog: PHedgehog): TAmmoType; 
74a04089bb56
Suggestion of sheepluva's  disable timebox in crates after SD, and set to disabled in Ammo. Also disable switch hedgehog for teams of 1 hedgehog in size, and try and correct what appears to be a bug in reserved hats.
nemo
parents:
6472
diff
changeset

43 
function GetUtility(Hedgehog: PHedgehog): 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; 
6543  55 
procedure doStepDrowningGear(Gear: PGear); 
4385  56 

4  57 

58 
implementation 

4393  59 
uses uStore, uSound, uTeams, uRandom, uCollisions, uIO, uLandGraphics, 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

60 
uAIMisc, uLocale, uAI, uAmmos, uStats, uVisualGears, uScript, GLunit, uMobile, uVariables, 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

61 
uCommands, uUtils, uTextures, uRenderUtils, uGearsRender, uCaptions, uDebug, uLandTexture, 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

62 
uGearsHedgehog, uGearsUtils, uGearsList; 
789  63 

3697  64 

371  65 
procedure AmmoShove(Ammo: PGear; Damage, Power: LongInt); forward; 
1433  66 
//procedure AmmoFlameWork(Ammo: PGear); forward; 
4034
634a8c8682de
add some phone rumbling to big explosions, airbomb and sinegun
koda
parents:
4024
diff
changeset

67 
function GearsNear(X, Y: hwFloat; Kind: TGearType; r: LongInt): TPGearArray; forward; 
15  68 
procedure SpawnBoxOfSmth; forward; 
506  69 
procedure ShotgunShot(Gear: 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

70 
procedure doStepCase(Gear: PGear); forward; 
1964  71 

5121
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset

72 
// 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

73 
// separate files. 
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset

74 
// 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

75 
// than the handlers for all other gears. 
2599  76 
{$INCLUDE "GSHandlers.inc"} 
4  77 

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

79 
var Gear: PGear; 

1849  80 
dmg: LongInt; 
4  81 
begin 
351  82 
CheckNoDamage:= true; 
4  83 
Gear:= GearsList; 
84 
while Gear <> nil do 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

85 
begin 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

86 
if (Gear^.Kind = gtHedgehog) and (((GameFlags and gfInfAttack) = 0) or ((Gear^.dX.QWordValue < _0_000004.QWordValue) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

87 
and (Gear^.dY.QWordValue < _0_000004.QWordValue))) then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

88 
begin 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

89 
if (not isInMultiShoot) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

90 
inc(Gear^.Damage, Gear^.Karma); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

91 
if (Gear^.Damage <> 0) and (not Gear^.Invulnerable) then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

92 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

93 
CheckNoDamage:= false; 
4824  94 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

95 
dmg:= Gear^.Damage; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

96 
if Gear^.Health < dmg then 
3453  97 
begin 
98 
Gear^.Active:= true; 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

99 
Gear^.Health:= 0 
3453  100 
end 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

101 
else 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

102 
dec(Gear^.Health, dmg); 
351  103 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

104 
if (Gear^.Hedgehog^.Team = CurrentTeam) and (Gear^.Damage <> Gear^.Karma) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

105 
and (not Gear^.Hedgehog^.King) and (not Gear^.Hedgehog^.Effects[hePoisoned]) and (not SuddenDeathDmg) then 
2017  106 
Gear^.State:= Gear^.State or gstLoser; 
107 

3461
0781275649e9
revert the restoration of nonvgt health gears. desyncs continued with it, and furthermore, occur in r3489 too
nemo
parents:
3460
diff
changeset

108 
spawnHealthTagForHH(Gear, dmg); 
867  109 

4365  110 
RenderHealth(Gear^.Hedgehog^); 
111 
RecountTeamHealth(Gear^.Hedgehog^.Team); 

1505  112 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

113 
end; 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

114 
if (not isInMultiShoot) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

115 
Gear^.Karma:= 0; 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

116 
Gear^.Damage:= 0 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

117 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

118 
Gear:= Gear^.NextGear 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

119 
end; 
4  120 
end; 
121 

1054  122 
procedure HealthMachine; 
123 
var Gear: PGear; 

2824
2d25e49bc2e8
Extra incentive to attack nonking hogs. If king loses his entourage, he loses 5hp per turn
nemo
parents:
2814
diff
changeset

124 
team: PTeam; 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

125 
i: LongWord; 
2824
2d25e49bc2e8
Extra incentive to attack nonking hogs. If king loses his entourage, he loses 5hp per turn
nemo
parents:
2814
diff
changeset

126 
flag: Boolean; 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

127 
tmp: LongWord; 
1054  128 
begin 
3682  129 
Gear:= GearsList; 
1054  130 

3682  131 
while Gear <> nil do 
132 
begin 

133 
if Gear^.Kind = gtHedgehog then 

134 
begin 

135 
tmp:= 0; 

4365  136 
if Gear^.Hedgehog^.Effects[hePoisoned] then 
4111  137 
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

138 
inc(tmp, ModifyDamage(5, Gear)); 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

139 
if (GameFlags and gfResetHealth) <> 0 then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

140 
dec(Gear^.Hedgehog^.InitialHealth) // does not need a minimum check since <= 1 basically disables it 
4111  141 
end; 
4153
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset

142 
if (TotalRounds > cSuddenDTurns  1) then 
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset

143 
begin 
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset

144 
inc(tmp, cHealthDecrease); 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

145 
if (GameFlags and gfResetHealth) <> 0 then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

146 
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

147 
end; 
4365  148 
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

149 
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

150 
flag:= false; 
4365  151 
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

152 
for i:= 0 to Pred(team^.HedgehogsNumber) do 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

153 
if (team^.Hedgehogs[i].Gear <> nil) and (not team^.Hedgehogs[i].King) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

154 
and (team^.Hedgehogs[i].Gear^.Health > team^.Hedgehogs[i].Gear^.Damage) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

155 
flag:= true; 
4111  156 
if not flag then 
157 
begin 

158 
inc(tmp, 5); 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

159 
if (GameFlags and gfResetHealth) <> 0 then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

160 
dec(Gear^.Hedgehog^.InitialHealth, 5) 
4111  161 
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

162 
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

163 
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

164 
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

165 
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

166 
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

167 
end 
3682  168 
end; 
1054  169 

3682  170 
Gear:= Gear^.NextGear 
171 
end; 

1054  172 
end; 
173 

4  174 
procedure ProcessGears; 
614  175 
const delay: LongWord = 0; 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

176 
delay2: LongWord = 0; 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

177 
step: (stDelay, stChDmg, stSweep, stTurnReact, 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

178 
stAfterDelay, stChWin, stWater, stChWin2, stHealth, 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

179 
stSpawn, stNTurn) = stDelay; 
4  180 
var Gear, t: PGear; 
4207
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset

181 
i, AliveCount: LongInt; 
3331  182 
s: shortstring; 
4  183 
begin 
868  184 
PrvInactive:= AllInactive; 
4  185 
AllInactive:= true; 
1495  186 

2940  187 
if (StepSoundTimer > 0) and (StepSoundChannel < 0) then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

188 
StepSoundChannel:= LoopSound(sndSteps) 
2940  189 
else if (StepSoundTimer = 0) and (StepSoundChannel > 1) then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

190 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

191 
StopSound(StepSoundChannel); 
2993
d83edb74e92d
Remove animation on jumping/resuming walk, only leave it in on weapon switch
nemo
parents:
2991
diff
changeset

192 
StepSoundChannel:= 1 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

193 
end; 
2940  194 

195 
if StepSoundTimer > 0 then 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

196 
dec(StepSoundTimer, 1); 
2940  197 

4  198 
t:= GearsList; 
1054  199 
while t <> nil do 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

200 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

201 
Gear:= t; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

202 
t:= Gear^.NextGear; 
3123  203 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

204 
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

205 
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

206 
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

207 
begin 
6380
1ff5ad1d771b
Remove a bunch of unnecessary nil checks. FreeTexture does its own nil check.
nemo
parents:
6299
diff
changeset

208 
FreeTexture(Gear^.Tex); 
2619  209 
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

210 
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

211 
Gear^.doStep(Gear); 
3848  212 
// might be useful later 
4492  213 
//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

214 
end 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

215 
end; 
89  216 

4  217 
if AllInactive then 
1343  218 
case step of 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

219 
stDelay: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

220 
begin 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

221 
if delay = 0 then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

222 
delay:= cInactDelay 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

223 
else 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

224 
dec(delay); 
614  225 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

226 
if delay = 0 then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

227 
inc(step) 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

228 
end; 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

229 

6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

230 
stChDmg: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

231 
if CheckNoDamage then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

232 
inc(step) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

233 
else 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

234 
step:= stDelay; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

235 

6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

236 
stSweep: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

237 
if SweepDirty then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

238 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

239 
SetAllToActive; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

240 
step:= stChDmg 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

241 
end 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

242 
else 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

243 
inc(step); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

244 

6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

245 
stTurnReact: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

246 
begin 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

247 
if (not bBetweenTurns) and (not isInMultiShoot) then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

248 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

249 
uStats.TurnReaction; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

250 
inc(step) 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

251 
end 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

252 
else 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

253 
inc(step, 2); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

254 
end; 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

255 

6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

256 
stAfterDelay: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

257 
begin 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

258 
if delay = 0 then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

259 
delay:= cInactDelay 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

260 
else 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

261 
dec(delay); 
815  262 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

263 
if delay = 0 then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

264 
inc(step) 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

265 
end; 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

266 
stChWin: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

267 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

268 
CheckForWin; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

269 
inc(step) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

270 
end; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

271 
stWater: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

272 
if (not bBetweenTurns) and (not isInMultiShoot) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

273 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

274 
if TotalRounds = cSuddenDTurns + 1 then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

275 
bWaterRising:= true; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

276 
if bWaterRising and (cWaterRise > 0) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

277 
AddGear(0, 0, gtWaterUp, 0, _0, _0, 0)^.Tag:= cWaterRise; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

278 
inc(step) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

279 
end 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

280 
else 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

281 
inc(step); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

282 
stChWin2: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

283 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

284 
CheckForWin; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

285 
inc(step) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

286 
end; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

287 

6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

288 
stHealth: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

289 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

290 
if (cWaterRise <> 0) or (cHealthDecrease <> 0) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

291 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

292 
if (TotalRounds = cSuddenDTurns) and (not SuddenDeath) and (not isInMultiShoot) then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

293 
begin 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

294 
SuddenDeath:= true; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

295 
if cHealthDecrease <> 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

296 
begin 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

297 
SuddenDeathDmg:= true; 
5558
49cfd05ccb83
new SD flakes from mikade and a flash when sudden death starts
Henek
parents:
5556
diff
changeset

298 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

299 
// flash 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

300 
ScreenFade:= sfFromWhite; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

301 
ScreenFadeValue:= sfMax; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

302 
ScreenFadeSpeed:= 1; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

303 

6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

304 
ChangeToSDClouds; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

305 
ChangeToSDFlakes; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

306 
glClearColor(SDSkyColor.r * (SDTint/255) / 255, SDSkyColor.g * (SDTint/255) / 255, SDSkyColor.b * (SDTint/255) / 255, 0.99); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

307 
Ammoz[amTardis].SkipTurns:= 9999; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

308 
Ammoz[amTardis].Probability:= 0; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

309 
end; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

310 
AddCaption(trmsg[sidSuddenDeath], cWhiteColor, capgrpGameState); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

311 
playSound(sndSuddenDeath); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

312 
StopMusic //No SDMusic for now 
6472  313 
//MusicFN:= SDMusic; 
314 
//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

315 
end 
6453
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6380
diff
changeset

316 
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

317 
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

318 
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

319 
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

320 
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

321 
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

322 
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

323 
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

324 
end; 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

325 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

326 
if bBetweenTurns 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

327 
or isInMultiShoot 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

328 
or (TotalRounds = 1) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

329 
inc(step) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

330 
else 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

331 
begin 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

332 
bBetweenTurns:= true; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

333 
HealthMachine; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

334 
step:= stChDmg 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

335 
end 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

336 
end; 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

337 
stSpawn: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

338 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

339 
if not isInMultiShoot then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

340 
SpawnBoxOfSmth; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

341 
inc(step) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

342 
end; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

343 
stNTurn: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

344 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

345 
if isInMultiShoot then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

346 
isInMultiShoot:= false 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

347 
else 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

348 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

349 
// delayed till after 0.9.12 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

350 
// reset to default zoom 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

351 
//ZoomValue:= ZoomDefault; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

352 
with CurrentHedgehog^ do 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

353 
if (Gear <> nil) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

354 
and ((Gear^.State and gstAttacked) = 0) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

355 
and (MultiShootAttacks > 0) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

356 
OnUsedAmmo(CurrentHedgehog^); 
3697  357 

3396
e5b3e5f2818e
More portal changes. Allows for a multishoot utility. Hopefully not breaking anything.
nemo
parents:
3390
diff
changeset

358 
EndTurnCleanup; 
2376  359 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

360 
FreeActionsList; // could send left, right and similar commands, so should be called before /nextturn 
1298  361 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

362 
ParseCommand('/nextturn', true); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

363 
SwitchHedgehog; 
1298  364 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

365 
AfterSwitchHedgehog; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

366 
bBetweenTurns:= false 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

367 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

368 
step:= Low(step) 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

369 
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

370 
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

371 
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

372 
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

373 
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

374 
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

375 
else 
3957  376 
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

377 
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

378 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

379 
if ((delay2 mod cInactDelay) = 0) and (CurrentHedgehog <> nil) and (CurrentHedgehog^.Gear <> nil) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

380 
and (not CurrentHedgehog^.Unplaced) then 
5507
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5501
diff
changeset

381 
begin 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

382 
if (CurrentHedgehog^.Gear^.State and gstAttacked <> 0) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

383 
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

384 
begin 
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5501
diff
changeset

385 
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

386 
isCursorVisible := true 
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5501
diff
changeset

387 
end; 
6453
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6380
diff
changeset

388 
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

389 
end; 
3957  390 
if delay2 = 0 then 
391 
begin 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

392 
if (CurrentHedgehog^.Gear <> nil) and (CurrentHedgehog^.Gear^.State and gstAttacked = 0) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

393 
and (CurAmmoGear = nil) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

394 
SweepDirty; 
3957  395 
CheckNoDamage; 
4207
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset

396 
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

397 
for i:= 0 to Pred(ClansCount) do 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

398 
if ClansArray[i]^.ClanHealth > 0 then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

399 
inc(AliveCount); 
4207
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset

400 
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

401 
begin 
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset

402 
step:= stChDmg; 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

403 
if TagTurnTimeLeft = 0 then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

404 
TagTurnTimeLeft:= TurnTimeLeft; 
4207
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset

405 
TurnTimeLeft:= 0 
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset

406 
end 
3957  407 
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

408 
end 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

409 
end; 
15  410 

4  411 
if TurnTimeLeft > 0 then 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

412 
if CurrentHedgehog^.Gear <> nil then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

413 
if ((CurrentHedgehog^.Gear^.State and gstAttacking) = 0) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

414 
and (not isInMultiShoot) then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

415 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

416 
if (TurnTimeLeft = 5000) 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

417 
and (cHedgehogTurnTime >= 10000) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

418 
and (not PlacingHogs) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

419 
and (CurrentHedgehog^.Gear <> nil) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

420 
and ((CurrentHedgehog^.Gear^.State and gstAttacked) = 0) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

421 
AddVoice(sndHurry, CurrentTeam^.voicepack); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

422 
if ReadyTimeLeft > 0 then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

423 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

424 
if ReadyTimeLeft = 2000 then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

425 
AddVoice(sndComeonthen, CurrentTeam^.voicepack); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

426 
dec(ReadyTimeLeft) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

427 
end 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

428 
else 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

429 
dec(TurnTimeLeft) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

430 
end; 
351  431 

2621
956ff066f3a5
Fix desync when playing with AI via network, occuring in certain conditions
unc0rr
parents:
2619
diff
changeset

432 
if skipFlag then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

433 
begin 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

434 
if TagTurnTimeLeft = 0 then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

435 
TagTurnTimeLeft:= TurnTimeLeft; 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

436 
TurnTimeLeft:= 0; 
3784
75aa91bea32b
Extend statistics collection (TeamKills, TurnSkips, TeamDamage)
burp
parents:
3775
diff
changeset

437 
skipFlag:= false; 
75aa91bea32b
Extend statistics collection (TeamKills, TurnSkips, TeamDamage)
burp
parents:
3775
diff
changeset

438 
inc(CurrentHedgehog^.Team^.stats.TurnSkips); 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

439 
end; 
2621
956ff066f3a5
Fix desync when playing with AI via network, occuring in certain conditions
unc0rr
parents:
2619
diff
changeset

440 

2134  441 
if ((GameTicks and $FFFF) = $FFFF) then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

442 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

443 
if (not CurrentTeam^.ExtDriven) then 
5810  444 
begin 
445 
SendIPC('#'); 

446 
AddFileLog('hiTicks increment message sent') 

447 
end; 

2134  448 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

449 
if (not CurrentTeam^.ExtDriven) or CurrentTeam^.hasGone then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

450 
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

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

452 

4417
6bf00d99fc47
move this call to where the game tick is actually incremented
nemo
parents:
4406
diff
changeset

453 
ScriptCall('onGameTick'); 
515  454 
inc(GameTicks) 
4  455 
end; 
456 

3396
e5b3e5f2818e
More portal changes. Allows for a multishoot utility. Hopefully not breaking anything.
nemo
parents:
3390
diff
changeset

457 
//Purpose, to reset all transient attributes toggled by a utility and clean up various gears and effects at end of turn 
1854  458 
//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

459 
procedure EndTurnCleanup; 
1865
ebc6dfca60d4
 nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1863
diff
changeset

460 
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

461 
t: PGear; 
1849  462 
begin 
2221  463 
SpeechText:= ''; // in case it has not been consumed 
2017  464 

1895  465 
if (GameFlags and gfLowGravity) = 0 then 
4623  466 
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

467 
cGravity:= cMaxWindSpeed * 2; 
4623  468 
cGravityf:= 0.00025 * 2 
469 
end; 

1895  470 

2017  471 
if (GameFlags and gfVampiric) = 0 then 
472 
cVampiric:= false; 

473 

1849  474 
cDamageModifier:= _1; 
1895  475 

476 
if (GameFlags and gfLaserSight) = 0 then 

477 
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

478 

41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset

479 
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

480 
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

481 
// 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

482 
if (CurrentTeam <> nil) then 
4099  483 
with CurrentTeam^ do 
484 
for i:= 0 to cMaxHHIndex do 

485 
with Hedgehogs[i] do 

486 
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

487 
(* 
4099  488 
if (SpeechGear <> nil) then 
489 
begin 

490 
DeleteVisualGear(SpeechGear); // remove to restore persisting beyond end of turn. Tiy says was too much of a gameplay issue 

491 
SpeechGear:= nil 

492 
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

493 
*) 
2045
b0588498bc3a
 Fix network (my crappy fault, triggered by nemo's patch)
unc0rr
parents:
2042
diff
changeset

494 

4099  495 
if (Gear <> nil) then 
496 
begin 

497 
if (GameFlags and gfInvulnerable) = 0 then 

498 
Gear^.Invulnerable:= false; 

499 
end; 

500 
end; 

3480
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset

501 
t:= GearsList; 
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset

502 
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

503 
begin 
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset

504 
t^.PortalCounter:= 0; 
4372  505 
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

506 
begin 
4372  507 
t^.Health:= t^.Hedgehog^.InitialHealth; 
508 
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

509 
end; 
3480
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset

510 
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

511 
end; 
41e06b74c991
Enable resetting of weapons after each turn  useful in combination with a limited weaponset and unlimited attacks
nemo
parents:
3908
diff
changeset

512 

6453
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6380
diff
changeset

513 
if ((GameFlags and gfResetWeps) <> 0) and (not PlacingHogs) then 
4099  514 
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

515 

4099  516 
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

517 
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

518 
RecountTeamHealth(TeamsArray[i]) 
1849  519 
end; 
2045
b0588498bc3a
 Fix network (my crappy fault, triggered by nemo's patch)
unc0rr
parents:
2042
diff
changeset

520 

4  521 
procedure SetAllToActive; 
522 
var t: PGear; 

523 
begin 

524 
AllInactive:= false; 

525 
t:= GearsList; 

351  526 
while t <> nil do 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

527 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

528 
t^.Active:= true; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

529 
t:= t^.NextGear 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

530 
end 
4  531 
end; 
532 

533 
procedure SetAllHHToActive; 

534 
var t: PGear; 

535 
begin 

536 
AllInactive:= false; 

537 
t:= GearsList; 

351  538 
while t <> nil do 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

539 
begin 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

540 
if (t^.Kind = gtHedgehog) or (t^.Kind = gtExplosives) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

541 
t^.Active:= true; 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

542 
t:= t^.NextGear 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

543 
end 
4  544 
end; 
545 

4385  546 

547 
procedure DrawGears; 

548 
var Gear: PGear; 

549 
x, y: LongInt; 

2802  550 
begin 
4385  551 
Gear:= GearsList; 
552 
while Gear <> nil do 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

553 
begin 
5348
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset

554 
if Gear^.State and gstInvisible = 0 then 
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset

555 
begin 
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset

556 
x:= hwRound(Gear^.X) + WorldDx; 
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset

557 
y:= hwRound(Gear^.Y) + WorldDy; 
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset

558 
RenderGear(Gear, x, y); 
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset

559 
end; 
4385  560 
Gear:= Gear^.NextGear 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

561 
end; 
2802  562 
end; 
563 

4  564 
procedure FreeGearsList; 
565 
var t, tt: PGear; 

566 
begin 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

567 
tt:= GearsList; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

568 
GearsList:= nil; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

569 
while tt <> nil do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

570 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

571 
t:= tt; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

572 
tt:= tt^.NextGear; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

573 
Dispose(t) 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

574 
end; 
4  575 
end; 
576 

10  577 
procedure AddMiscGears; 
5179
8d64dcb566ea
Fix "Mixing signed expressions and longwords gives a 64bit result" warnings
unc0rr
parents:
5139
diff
changeset

578 
var i: Longword; 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

579 
Gear: PGear; 
4  580 
begin 
498  581 
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

582 

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

583 
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

584 
Gear:= PGear(1); 
4834  585 
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

586 
begin 
4148
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset

587 
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

588 
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

589 
inc(i) 
4148
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset

590 
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

591 

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

592 
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

593 
Gear:= PGear(1); 
4833  594 
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

595 
begin 
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset

596 
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

597 
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

598 
inc(i) 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

599 
end; 
1895  600 

601 
if (GameFlags and gfLowGravity) <> 0 then 

4623  602 
begin 
3355
dc9e61e67484
cWindSpeed recalculation assumed GetRandom returns a value between 0.01.0 while in fact is in the 0.00.5 range; Halve cMaxWindSpeed to compensate.
palewolf
parents:
3350
diff
changeset

603 
cGravity:= cMaxWindSpeed; 
4623  604 
cGravityf:= 0.00025 
605 
end; 

1895  606 

2017  607 
if (GameFlags and gfVampiric) <> 0 then 
608 
cVampiric:= true; 

609 

1895  610 
Gear:= GearsList; 
611 
if (GameFlags and gfInvulnerable) <> 0 then 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

612 
while Gear <> nil do 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

613 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

614 
Gear^.Invulnerable:= true; // this is only checked on hogs right now, so no need for gear type check 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

615 
Gear:= Gear^.NextGear 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

616 
end; 
1895  617 

618 
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

619 
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

620 

41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset

621 
if (GameFlags and gfArtillery) <> 0 then 
4611  622 
cArtillery:= true; 
623 

5015  624 
if not hasBorder and ((Theme = 'Snow') or (Theme = 'Christmas')) then 
4621  625 
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

626 
AddGear(GetRandom(LAND_WIDTH+1024)512, LAND_HEIGHT  GetRandom(LAND_HEIGHT div 2), gtFlake, 0, _0, _0, 0); 
4  627 
end; 
628 

629 

506  630 
procedure ShotgunShot(Gear: PGear); 
631 
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

632 
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

633 
dx, dy: hwFloat; 
506  634 
begin 
509  635 
Gear^.Radius:= cShotgunRadius; 
506  636 
t:= GearsList; 
637 
while t <> nil do 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

638 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

639 
case t^.Kind of 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

640 
gtHedgehog, 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

641 
gtMine, 
3710  642 
gtSMine, 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

643 
gtCase, 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

644 
gtTarget, 
4881
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4867
diff
changeset

645 
gtExplosives, 
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4867
diff
changeset

646 
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

647 
//addFileLog('ShotgunShot radius: ' + inttostr(Gear^.Radius) + ', t^.Radius = ' + inttostr(t^.Radius) + ', distance = ' + inttostr(dist) + ', dmg = ' + inttostr(dmg)); 
5590  648 
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

649 
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

650 
dx:= Gear^.Xt^.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

651 
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

652 
dy:= Gear^.Yt^.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

653 
dy.isNegative:= false; 
5590  654 
if rhwRound(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

655 
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

656 
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

657 
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

658 
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

659 
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

660 
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

661 
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

662 
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

663 
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

664 
Gear^.State:= Gear^.State or gstWinner; 
867  665 

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

666 
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

667 
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

668 
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

669 
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

670 
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

671 
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

672 
end 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

673 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

674 
gtGrave: begin 
5590  675 
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

676 
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

677 
dx:= Gear^.Xt^.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

678 
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

679 
dy:= Gear^.Yt^.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

680 
dy.isNegative:= false; 
5590  681 
if rhwRound(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

682 
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

683 
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

684 
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

685 
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

686 
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

687 
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

688 
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

689 
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

690 
end 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

691 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

692 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

693 
t:= t^.NextGear 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

694 
end; 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

695 
if (GameFlags and gfSolidLand) = 0 then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

696 
DrawExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), cShotgunRadius) 
506  697 
end; 
698 

371  699 
procedure AmmoShove(Ammo: PGear; Damage, Power: LongInt); 
53  700 
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

701 
Gear: PGear; 
2726  702 
i, tmpDmg: LongInt; 
4327  703 
VGear: PVisualGear; 
38  704 
begin 
53  705 
t:= CheckGearsCollision(Ammo); 
3098
e5a1bc4e56fd
Specifically check for current hedgehog being on rope, the tricky bastard.
nemo
parents:
3097
diff
changeset

706 
// Just to avoid hogs on rope dodging fire. 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

707 
if (CurAmmoGear <> nil) and ((CurAmmoGear^.Kind = gtRope) or (CurAmmoGear^.Kind = gtJetpack) or (CurAmmoGear^.Kind = gtBirdy)) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

708 
and (CurrentHedgehog^.Gear <> nil) and (CurrentHedgehog^.Gear^.CollisionIndex = 1) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

709 
and (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

710 
begin 
e5a1bc4e56fd
Specifically check for current hedgehog being on rope, the tricky bastard.
nemo
parents:
3097
diff
changeset

711 
t^.ar[t^.Count]:= CurrentHedgehog^.Gear; 
e5a1bc4e56fd
Specifically check for current hedgehog being on rope, the tricky bastard.
nemo
parents:
3097
diff
changeset

712 
inc(t^.Count) 
4182  713 
end; 
4165  714 

351  715 
i:= t^.Count; 
1506  716 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

717 
if (Ammo^.Kind = gtFlame) and (i > 0) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

718 
Ammo^.Health:= 0; 
53  719 
while i > 0 do 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

720 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

721 
dec(i); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

722 
Gear:= t^.ar[i]; 
2726  723 
tmpDmg:= ModifyDamage(Damage, Gear); 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

724 
if (Gear^.State and gstNoDamage) = 0 then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

725 
begin 
4824  726 

4329  727 
if (Ammo^.Kind = gtDEagleShot) or (Ammo^.Kind = gtSniperRifleShot) then 
4578  728 
begin 
4329  729 
VGear := AddVisualGear(hwround(Ammo^.X), hwround(Ammo^.Y), vgtBulletHit); 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

730 
if VGear <> nil then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

731 
VGear^.Angle := DxDy2Angle(Ammo^.dX, Ammo^.dY); 
4329  732 
end; 
4824  733 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

734 
if (Gear^.Kind = gtHedgehog) and (Ammo^.State and gsttmpFlag <> 0) and (Ammo^.Kind = gtShover) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

735 
Gear^.FlightTime:= 1; 
3697  736 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

737 
case Gear^.Kind of 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

738 
gtHedgehog, 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

739 
gtMine, 
3710  740 
gtSMine, 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

741 
gtTarget, 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

742 
gtCase, 
4881
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4867
diff
changeset

743 
gtExplosives, 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

744 
gtStructure: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

745 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

746 
if (Ammo^.Kind = gtDrill) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

747 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

748 
Ammo^.Timer:= 0; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

749 
exit; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

750 
end; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

751 
if (not Gear^.Invulnerable) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

752 
ApplyDamage(Gear, Ammo^.Hedgehog, tmpDmg, dsShove) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

753 
else 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

754 
Gear^.State:= Gear^.State or gstWinner; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

755 
if (Gear^.Kind = gtExplosives) and (Ammo^.Kind = gtBlowtorch) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

756 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

757 
if (Ammo^.Hedgehog^.Gear <> nil) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

758 
Ammo^.Hedgehog^.Gear^.State:= Ammo^.Hedgehog^.Gear^.State and (not gstNotKickable); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

759 
ApplyDamage(Gear, Ammo^.Hedgehog, tmpDmg * 100, dsUnknown); // crank up damage for explosives + blowtorch 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

760 
end; 
867  761 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

762 
DeleteCI(Gear); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

763 
if (Gear^.Kind = gtHedgehog) and Gear^.Hedgehog^.King then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

764 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

765 
Gear^.dX:= Ammo^.dX * Power * _0_005; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

766 
Gear^.dY:= Ammo^.dY * Power * _0_005 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

767 
end 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

768 
else 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

769 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

770 
Gear^.dX:= Ammo^.dX * Power * _0_01; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

771 
Gear^.dY:= Ammo^.dY * Power * _0_01 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

772 
end; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

773 

6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

774 
Gear^.Active:= true; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

775 
Gear^.State:= Gear^.State or gstMoving; 
2728
640916bedea7
Adjust king movement in ammoshove, give king a damage bonus
nemo
parents:
2726
diff
changeset

776 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

777 
if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

778 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

779 
if not (TestCollisionXwithXYShift(Gear, _0, 3, hwSign(Gear^.dX)) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

780 
or (TestCollisionYwithGear(Gear, 1) <> 0)) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

781 
Gear^.Y:= Gear^.Y  _1; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

782 
if not (TestCollisionXwithXYShift(Gear, _0, 2, hwSign(Gear^.dX)) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

783 
or (TestCollisionYwithGear(Gear, 1) <> 0)) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

784 
Gear^.Y:= Gear^.Y  _1; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

785 
if not (TestCollisionXwithXYShift(Gear, _0, 1, hwSign(Gear^.dX)) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

786 
or (TestCollisionYwithGear(Gear, 1) <> 0)) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

787 
Gear^.Y:= Gear^.Y  _1; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

788 
end; 
867  789 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

790 
if (Ammo^.Kind <> gtFlame) or ((Ammo^.State and gsttmpFlag) = 0) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

791 
FollowGear:= Gear 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

792 
end; 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

793 
end 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

794 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

795 
end; 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

796 
if i <> 0 then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

797 
SetAllToActive 
38  798 
end; 
799 

4  800 
procedure AssignHHCoords; 
955  801 
var i, t, p, j: LongInt; 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

802 
ar: array[0..Pred(cMaxHHs)] of PHedgehog; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

803 
Count: Longword; 
4  804 
begin 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

805 
if (GameFlags and gfPlaceHog) <> 0 then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

806 
PlacingHogs:= true; 
4148
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset

807 
if (GameFlags and gfDivideTeams) <> 0 then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

808 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

809 
t:= 0; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

810 
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

811 
for p:= 0 to 1 do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

812 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

813 
with ClansArray[p]^ do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

814 
for j:= 0 to Pred(TeamsNumber) do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

815 
with Teams[j]^ do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

816 
for i:= 0 to cMaxHHIndex do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

817 
with Hedgehogs[i] do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

818 
if (Gear <> nil) and (Gear^.X.QWordValue = 0) then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

819 
begin 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

820 
if PlacingHogs then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

821 
Unplaced:= true 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

822 
else 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

823 
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

824 
if Gear <> nil then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

825 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

826 
Gear^.Pos:= GetRandom(49); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

827 
Gear^.dX.isNegative:= p = 1; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

828 
end 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

829 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

830 
t:= LAND_WIDTH div 2 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

831 
end 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

832 
end else // mix hedgehogs 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

833 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

834 
Count:= 0; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

835 
for p:= 0 to Pred(TeamsCount) do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

836 
with TeamsArray[p]^ do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

837 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

838 
for i:= 0 to cMaxHHIndex do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

839 
with Hedgehogs[i] do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

840 
if (Gear <> nil) and (Gear^.X.QWordValue = 0) then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

841 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

842 
ar[Count]:= @Hedgehogs[i]; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

843 
inc(Count) 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

844 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

845 
end; 
1792  846 
// unC0Rr, while it is true user can watch value on map screen, IMO this (and check above) should be enforced in UI 
847 
//  is there a good place to put values for the different widgets to check? Right now they are kind of disconnected. 

1965  848 
//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

849 
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

850 
while (Count > 0) do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

851 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

852 
i:= GetRandom(Count); 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

853 
if PlacingHogs then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

854 
ar[i]^.Unplaced:= true 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

855 
else 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

856 
FindPlace(ar[i]^.Gear, false, 0, LAND_WIDTH); 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

857 
if ar[i]^.Gear <> nil then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

858 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

859 
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

860 
ar[i]^.Gear^.Pos:= GetRandom(19) 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

861 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

862 
ar[i]:= ar[Count  1]; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

863 
dec(Count) 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

864 
end 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

865 
end 
4  866 
end; 
867 

4024
1ffb84b3823d
Resurrector: respect modified Gear position for resurrection range circle
Tobias Neumann <mail@tobiasneumann.eu>
parents:
4007
diff
changeset

868 
function GearsNear(X, Y: hwFloat; Kind: TGearType; r: LongInt): TPGearArray; 
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobiasneumann.eu>
parents:
3957
diff
changeset

869 
var 
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobiasneumann.eu>
parents:
3957
diff
changeset

870 
t: PGear; 
5556  871 
l: Longword; 
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobiasneumann.eu>
parents:
3957
diff
changeset

872 
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

873 
r:= r*r; 
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobiasneumann.eu>
parents:
3957
diff
changeset

874 
GearsNear := nil; 
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobiasneumann.eu>
parents:
3957
diff
changeset

875 
t := GearsList; 
5556  876 
while t <> nil do 
877 
begin 

878 
if (t^.Kind = Kind) 

879 
and ((X  t^.X)*(X  t^.X) + (Y  t^.Y)*(Yt^.Y) < int2hwFloat(r)) then 

3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobiasneumann.eu>
parents:
3957
diff
changeset

880 
begin 
5556  881 
l:= Length(GearsNear); 
882 
SetLength(GearsNear, l + 1); 

883 
GearsNear[l] := t; 

3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobiasneumann.eu>
parents:
3957
diff
changeset

884 
end; 
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobiasneumann.eu>
parents:
3957
diff
changeset

885 
t := t^.NextGear; 
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobiasneumann.eu>
parents:
3957
diff
changeset

886 
end; 
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobiasneumann.eu>
parents:
3957
diff
changeset

887 
end; 
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobiasneumann.eu>
parents:
3957
diff
changeset

888 

1433  889 
{procedure AmmoFlameWork(Ammo: PGear); 
79  890 
var t: PGear; 
891 
begin 

892 
t:= GearsList; 

893 
while t <> nil do 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

894 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

895 
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

896 
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

897 
begin 
2017  898 
ApplyDamage(t, 5); 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

899 
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

900 
t^.dY:=  _0_25; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

901 
t^.Active:= true; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

902 
DeleteCI(t); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

903 
FollowGear:= t 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

904 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

905 
t:= t^.NextGear 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

906 
end; 
1433  907 
end;} 
79  908 

16  909 

910 
function CountGears(Kind: TGearType): Longword; 

911 
var t: PGear; 

2695  912 
count: Longword = 0; 
16  913 
begin 
2695  914 

16  915 
t:= GearsList; 
916 
while t <> nil do 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

917 
begin 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

918 
if t^.Kind = Kind then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

919 
inc(count); 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

920 
t:= t^.NextGear 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

921 
end; 
2695  922 
CountGears:= count; 
16  923 
end; 
924 

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

925 
function SpawnCustomCrateAt(x, y: LongInt; crate: TCrateType; content: Longword): PGear; 
3730  926 
begin 
3734  927 
FollowGear := AddGear(x, y, gtCase, 0, _0, _0, 0); 
928 
cCaseFactor := 0; 

929 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

930 
if (crate <> HealthCrate) and (content > ord(High(TAmmoType))) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

931 
content := ord(High(TAmmoType)); 
3734  932 

933 
case crate of 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

934 
HealthCrate: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

935 
begin 
3734  936 
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

937 
FollowGear^.Health := content; 
3734  938 
AddCaption(GetEventString(eidNewHealthPack), cWhiteColor, capgrpAmmoInfo); 
939 
end; 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

940 
AmmoCrate: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

941 
begin 
3734  942 
FollowGear^.Pos := posCaseAmmo; 
4240
4e81670e52aa
er. and cast to TAmmoType, which burp's routine still requires :)
nemo
parents:
4239
diff
changeset

943 
FollowGear^.AmmoType := TAmmoType(content); 
3734  944 
AddCaption(GetEventString(eidNewAmmoPack), cWhiteColor, capgrpAmmoInfo); 
945 
end; 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

946 
UtilityCrate: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

947 
begin 
3734  948 
FollowGear^.Pos := posCaseUtility; 
4240
4e81670e52aa
er. and cast to TAmmoType, which burp's routine still requires :)
nemo
parents:
4239
diff
changeset

949 
FollowGear^.AmmoType := TAmmoType(content); 
3734  950 
AddCaption(GetEventString(eidNewUtilityPack), cWhiteColor, capgrpAmmoInfo); 
951 
end; 

952 
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

953 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

954 
if ( (x = 0) and (y = 0) ) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

955 
FindPlace(FollowGear, true, 0, LAND_WIDTH); 
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

956 

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

957 
SpawnCustomCrateAt := FollowGear; 
3730  958 
end; 
959 

5343  960 
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

961 
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

962 
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

963 
cCaseFactor := 0; 
5343  964 
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

965 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

966 
if explode then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

967 
FollowGear^.Pos := FollowGear^.Pos + posCaseExplode; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

968 
if poison then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

969 
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

970 

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

971 
case crate of 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

972 
HealthCrate: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

973 
begin 
5313
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset

974 
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

975 
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

976 
end; 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

977 
AmmoCrate: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

978 
begin 
5313
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset

979 
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

980 
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

981 
end; 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

982 
UtilityCrate: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

983 
begin 
5313
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset

984 
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

985 
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

986 
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

987 
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

988 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

989 
if ( (x = 0) and (y = 0) ) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

990 
FindPlace(FollowGear, true, 0, LAND_WIDTH); 
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

991 

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

992 
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

993 
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

994 

6515
74a04089bb56
Suggestion of sheepluva's  disable timebox in crates after SD, and set to disabled in Ammo. Also disable switch hedgehog for teams of 1 hedgehog in size, and try and correct what appears to be a bug in reserved hats.
nemo
parents:
6472
diff
changeset

995 
function GetAmmo(Hedgehog: PHedgehog): TAmmoType; 
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

996 
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

997 
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

998 
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

999 

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

1000 
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

1001 
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

1002 
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

1003 
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

1004 

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

1005 
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

1006 
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

1007 
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

1008 
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

1009 
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

1010 
while t >= 0 do 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1011 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1012 
inc(i); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1013 
if (Ammoz[i].Ammo.Propz and ammoprop_Utility) = 0 then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1014 
dec(t, Ammoz[i].Probability) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1015 
end 
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

1016 
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

1017 
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

1018 
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

1019 

6515
74a04089bb56
Suggestion of sheepluva's  disable timebox in crates after SD, and set to disabled in Ammo. Also disable switch hedgehog for teams of 1 hedgehog in size, and try and correct what appears to be a bug in reserved hats.
nemo
parents:
6472
diff
changeset

1020 
function GetUtility(Hedgehog: PHedgehog): TAmmoType; 
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

1021 
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

1022 
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

1023 
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

1024 

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

1025 
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

1026 
for i:= Low(TAmmoType) to High(TAmmoType) do 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1027 
if ((Ammoz[i].Ammo.Propz and ammoprop_Utility) <> 0) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1028 
and ((Hedgehog^.Team^.HedgehogsNumber > 1) or (Ammoz[i].Ammo.AmmoType <> amSwitch)) then 
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

1029 
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

1030 

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

1031 
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

1032 
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

1033 
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

1034 
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

1035 
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

1036 
while t >= 0 do 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1037 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1038 
inc(i); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1039 
if ((Ammoz[i].Ammo.Propz and ammoprop_Utility) <> 0) and ((Hedgehog^.Team^.HedgehogsNumber > 1) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1040 
or (Ammoz[i].Ammo.AmmoType <> amSwitch)) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1041 
dec(t, Ammoz[i].Probability) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1042 
end 
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

1043 
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

1044 
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

1045 
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

1046 

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

1047 

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

1048 

15  1049 
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

1050 
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

1051 
i: TAmmoType; 
15  1052 
begin 
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2760
diff
changeset

1053 
if (PlacingHogs) or 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1054 
(cCaseFactor = 0) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1055 
or (CountGears(gtCase) >= 5) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1056 
or (GetRandom(cCaseFactor) <> 0) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1057 
exit; 
1295  1058 

1948  1059 
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

1060 
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

1061 
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

1062 
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

1063 
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

1064 
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

1065 
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

1066 
inc(uTot, Ammoz[i].Probability); 
1966  1067 

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

1068 
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

1069 
a:=aTot; 
3268  1070 
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

1071 

3268  1072 
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

1073 
if ((GameFlags and gfInvulnerable) = 0) then 
3268  1074 
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

1075 
h:= cHealthCaseProb * 100; 
3268  1076 
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

1077 
a:= (10000h)*aTot div (aTot+uTot) 
3268  1078 
end 
3697  1079 
else 
3268  1080 
begin 
1081 
t:= GetRandom(aTot+uTot); 

1082 
h:= 0 

1083 
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

1084 

3697  1085 

3261
fa7086253e83
Rebalance Default to take into account reweighting of crates, remove redundant check
nemo
parents:
3259
diff
changeset

1086 
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

1087 
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

1088 
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

1089 
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

1090 
FollowGear^.Pos:= posCaseHealth; 
3331  1091 
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

1092 
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

1093 
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

1094 
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

1095 
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

1096 
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

1097 
begin 
1865
ebc6dfca60d4
 nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1863
diff
changeset

1098 
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

1099 
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

1100 
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

1101 
FollowGear^.Pos:= posCaseAmmo; 
4238
6f1631765ebd
Fix a longstanding 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

1102 
FollowGear^.AmmoType:= i; 
3331  1103 
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

1104 
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

1105 
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

1106 
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

1107 
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

1108 
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

1109 
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

1110 
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

1111 
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

1112 
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

1113 
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

1114 
FollowGear^.Pos:= posCaseUtility; 
4238
6f1631765ebd
Fix a longstanding 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

1115 
FollowGear^.AmmoType:= i; 
3331  1116 
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

1117 
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

1118 
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

1119 

1865
ebc6dfca60d4
 nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1863
diff
changeset

1120 
// 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

1121 
if (FollowGear <> nil) then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

1122 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

1123 
FindPlace(FollowGear, true, 0, LAND_WIDTH); 
2376  1124 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

1125 
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

1126 
AddVoice(sndReinforce, CurrentTeam^.voicepack) 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

1127 
end 
70  1128 
end; 
1129 

2726  1130 

2790  1131 
function GearByUID(uid : Longword) : PGear; 
1132 
var gear: PGear; 

1133 
begin 

1134 
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

1135 
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

1136 
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

1137 
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

1138 
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

1139 
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

1140 
end; 
2790  1141 
gear:= GearsList; 
1142 
while gear <> nil do 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

1143 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

1144 
if gear^.uid = uid then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

1145 
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

1146 
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

1147 
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

1148 
exit 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

1149 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

1150 
gear:= gear^.NextGear 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

1151 
end 
2790  1152 
end; 
1153 

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

1154 

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

1155 
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

1156 
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

1157 
s:= s; // avoid compiler hint 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1158 
if not CurrentTeam^.ExtDriven then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1159 
SendIPC(','); 
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

1160 
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

1161 
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

1162 
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

1163 

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

1164 
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

1165 
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

1166 
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

1167 
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

1168 
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

1169 
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

1170 
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

1171 
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

1172 
i:= 0; 
4469  1173 
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

1174 
x:= byte(s[1]); // speech type 
4469  1175 
if x < 4 then 
1176 
begin 

1177 
t:= byte(s[2]); // team 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1178 
if Length(s) > 2 then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1179 
h:= byte(s[3]) // target hog 
4469  1180 
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

1181 
// allow targetting a hog by specifying a number as the first portion of the text 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1182 
if (x < 4) and (h > byte('0')) and (h < byte('9')) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1183 
i:= h  48; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1184 
if i <> 0 then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1185 
text:= copy(s, 4, Length(s)  1) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1186 
else if x < 4 then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1187 
text:= copy(s, 3, Length(s)  1) 
4468  1188 
else text:= copy(s, 2, Length(s)  1); 
1189 

4470
d2b8d2fc51a9
disable say, just don't do anything. trying to avoid spew on spectator join
nemo
parents:
4469
diff
changeset

1190 
(* 
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

1191 
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

1192 
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

1193 
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

1194 
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

1195 
end; 
4470
d2b8d2fc51a9
disable say, just don't do anything. trying to avoid spew on spectator join
nemo
parents:
4469
diff
changeset

1196 
*) 
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

1197 

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

1198 
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

1199 
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

1200 
// if team matches current hedgehog team, default to current hedgehog 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1201 
if (i = 0) and (CurrentHedgehog <> nil) and (CurrentHedgehog^.Team = TeamsArray[t]) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

1202 
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

1203 
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

1204 
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

1205 
// 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

1206 
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

1207 
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

1208 
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

1209 
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

1210 
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

1211 
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

1212 
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

1213 
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

1214 
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

1215 
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

1216 
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

1217 
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

1218 
end; 
4784  1219 
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

1220 
begin 
4784  1221 
Gear:= AddVisualGear(0, 0, vgtSpeechBubble); 
1222 
if Gear <> nil then 

1223 
begin 

1224 
Gear^.Hedgehog:= hh; 

1225 
Gear^.Text:= text; 

1226 
Gear^.FrameTicks:= x 

1227 
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

1228 
end 
4706  1229 
//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

1230 
end 
4470
d2b8d2fc51a9
disable say, just don't do anything. trying to avoid spew on spectator join
nemo
parents:
4469
diff
changeset

1231 
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

1232 
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

1233 
SpeechType:= x3; 
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

1234 
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

1235 
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

1236 
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

1237 

3038  1238 
procedure initModule; 
6543  1239 
const handlers: array[TGearType] of TGearStepProcedure = ( 
1240 
@doStepBomb, 

1241 
@doStepHedgehog, 

1242 
@doStepShell, 

1243 
@doStepGrave, 

1244 
@doStepBee, 

1245 
@doStepShotgunShot, 

1246 
@doStepPickHammer, 

1247 
@doStepRope, 

1248 
@doStepMine, 

1249 
@doStepCase, 

1250 
@doStepDEagleShot, 

1251 
@doStepDynamite, 

1252 
@doStepBomb, 

1253 
@doStepCluster, 

1254 
@doStepShover, 

1255 
@doStepFlame, 

1256 
@doStepFirePunch, 

1257 
@doStepActionTimer, 

1258 
@doStepActionTimer, 

1259 
@doStepParachute, 

1260 
@doStepAirAttack, 

1261 
@doStepAirBomb, 

1262 
@doStepBlowTorch, 

1263 
@doStepGirder, 

1264 
@doStepTeleport, 

1265 
@doStepSwitcher, 

1266 
@doStepTarget, 

1267 
@doStepMortar, 

1268 
@doStepWhip, 

1269 
@doStepKamikaze, 

1270 
@doStepCake, 

1271 
@doStepSeduction, 

1272 
@doStepBomb, 

1273 
@doStepCluster, 

1274 
@doStepBomb, 

1275 
@doStepWaterUp, 

1276 
@doStepDrill, 

1277 
@doStepBallgun, 

1278 
@doStepBomb, 

1279 
@doStepRCPlane, 

1280 
@doStepSniperRifleShot, 

1281 
@doStepJetpack, 

1282 
@doStepMolotov, 

1283 
@doStepCase, 

1284 
@doStepBirdy, 

1285 
@doStepEggWork, 

1286 
@doStepPortalShot, 

1287 
@doStepPiano, 

1288 
@doStepBomb, 

1289 
@doStepSineGunShot, 

1290 
@doStepFlamethrower, 

1291 
@doStepSMine, 

1292 
@doStepPoisonCloud, 

1293 
@doStepHammer, 

1294 
@doStepHammerHit, 

1295 
@doStepResurrector, 
