author  nemo 
Sat, 18 Jan 2014 08:09:55 0500  
changeset 10012  82dd9f0c88f7 
parent 9998  736015b847e3 
child 10015  4feced261c68 
permissions  rwrr 
4  1 
(* 
1066  2 
* Hedgewars, a free turn based strategy game 
9998  3 
* Copyright (c) 20042014 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 
9777  36 
uses uConsts, uFloat, uTypes, uChat; 
3697  37 

3038  38 
procedure initModule; 
39 
procedure freeModule; 

7337
c224cd2d32f3
Allow script to set number of ammo in a crate. untested.
nemo
parents:
7335
diff
changeset

40 
function SpawnCustomCrateAt(x, y: LongInt; crate: TCrateType; content, cnt: Longword): PGear; 
5343  41 
function SpawnFakeCrateAt(x, y: LongInt; crate: TCrateType; explode: boolean; poison: boolean ): PGear; 
4  42 
procedure ProcessGears; 
3396
e5b3e5f2818e
More portal changes. Allows for a multishoot utility. Hopefully not breaking anything.
nemo
parents:
3390
diff
changeset

43 
procedure EndTurnCleanup; 
956  44 
procedure DrawGears; 
4  45 
procedure FreeGearsList; 
10  46 
procedure AddMiscGears; 
4  47 
procedure AssignHHCoords; 
3405  48 
function GearByUID(uid : Longword) : PGear; 
4  49 

50 
implementation 

9651  51 
uses uStore, uSound, uTeams, uRandom, uIO, uLandGraphics, 
52 
{$IFDEF USE_TOUCH_INTERFACE}uTouch,{$ENDIF} 

9295
f8819c3dde54
Remove some GLunit dependencies noticed on graph. uUtils was using it for GLfloat  but, the stuff it was returning to was usually converting to "real" anyway. uLand was including it unnecessarily. Minor refactor
nemo
parents:
9293
diff
changeset

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

54 
uCommands, uUtils, uTextures, uRenderUtils, uGearsRender, uCaptions, uDebug, uLandTexture, 
9285  55 
uGearsHedgehog, uGearsUtils, uGearsList, uGearsHandlersRope 
9293
873022596d15
You better test build before committing even trivial patches
unc0rr
parents:
9291
diff
changeset

56 
, uVisualGearsList, uGearsHandlersMess, uAI; 
789  57 

7028  58 
var skipFlag: boolean; 
3697  59 

6982  60 
var delay: LongWord; 
61 
delay2: LongWord; 

62 
step: (stDelay, stChDmg, stSweep, stTurnReact, 

63 
stAfterDelay, stChWin, stWater, stChWin2, stHealth, 

64 
stSpawn, stNTurn); 

8349
a1dbe148f10f
move onNewTurn, onGameTick and onGameTick20 to try and avoid ParseCommand breakage after nextturn call. Needs testing, but should be safe for most scripts. Also fix locale loading.
nemo
parents:
8204
diff
changeset

65 
NewTurnTick: LongWord; 
7021
0c75512a8920
adjust the scope of a few uSound variables and functions
koda
parents:
7010
diff
changeset

66 
//SDMusic: shortstring; 
6982  67 

4  68 
function CheckNoDamage: boolean; // returns TRUE in case of no damaged hhs 
69 
var Gear: PGear; 

1849  70 
dmg: LongInt; 
4  71 
begin 
351  72 
CheckNoDamage:= true; 
4  73 
Gear:= GearsList; 
74 
while Gear <> nil do 

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

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

76 
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

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

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

79 
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

80 
inc(Gear^.Damage, Gear^.Karma); 
9685
7d925e82e572
Tweak trophyrace to work better w/ skip (probably, needs testing), drop Invulnerable in favour of effects  heInvulnerable is already in effects,
nemo
parents:
9672
diff
changeset

81 
if (Gear^.Damage <> 0) and ((Gear^.Hedgehog^.Effects[heInvulnerable] = 0)) then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

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

83 
CheckNoDamage:= false; 
4824  84 

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

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

86 
if Gear^.Health < dmg then 
3453  87 
begin 
88 
Gear^.Active:= true; 

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

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

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

92 
dec(Gear^.Health, dmg); 
7882
35dfc54ba2c6
disable this block since it doesn't fit star's new graphic. doesn't show up often anyway, since unc0rr changed gst clearing
nemo
parents:
7850
diff
changeset

93 
(* 
35dfc54ba2c6
disable this block since it doesn't fit star's new graphic. doesn't show up often anyway, since unc0rr changed gst clearing
nemo
parents:
7850
diff
changeset

94 
This doesn't fit well w/ the new loser sprite which is cringing from an attack. 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

95 
if (Gear^.Hedgehog^.Team = CurrentTeam) and (Gear^.Damage <> Gear^.Karma) 
7010
10a0a31804f3
Switch effects to longint for convenience of tracking ice states. I could add a new Hedgehog value, but since we have this effects list being all useless as booleans anyway...
nemo
parents:
7007
diff
changeset

96 
and (not Gear^.Hedgehog^.King) and (Gear^.Hedgehog^.Effects[hePoisoned] = 0) and (not SuddenDeathDmg) then 
2017  97 
Gear^.State:= Gear^.State or gstLoser; 
7882
35dfc54ba2c6
disable this block since it doesn't fit star's new graphic. doesn't show up often anyway, since unc0rr changed gst clearing
nemo
parents:
7850
diff
changeset

98 
*) 
2017  99 

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

100 
spawnHealthTagForHH(Gear, dmg); 
867  101 

4365  102 
RenderHealth(Gear^.Hedgehog^); 
103 
RecountTeamHealth(Gear^.Hedgehog^.Team); 

1505  104 

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

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

106 
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

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

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

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

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

111 
end; 
4  112 
end; 
113 

1054  114 
procedure HealthMachine; 
115 
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

116 
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

117 
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

118 
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

119 
tmp: LongWord; 
1054  120 
begin 
3682  121 
Gear:= GearsList; 
1054  122 

3682  123 
while Gear <> nil do 
124 
begin 

125 
if Gear^.Kind = gtHedgehog then 

126 
begin 

127 
tmp:= 0; 

7010
10a0a31804f3
Switch effects to longint for convenience of tracking ice states. I could add a new Hedgehog value, but since we have this effects list being all useless as booleans anyway...
nemo
parents:
7007
diff
changeset

128 
if Gear^.Hedgehog^.Effects[hePoisoned] <> 0 then 
4111  129 
begin 
10012
82dd9f0c88f7
Make poison damage possibly variable (might as well since effects is a count). Scripts might find it handy.
nemo
parents:
9998
diff
changeset

130 
inc(tmp, ModifyDamage(Gear^.Hedgehog^.Effects[hePoisoned], Gear)); 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

131 
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

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

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

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

136 
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

137 
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

138 
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

139 
end; 
4365  140 
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

141 
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

142 
flag:= false; 
4365  143 
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

144 
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

145 
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

146 
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

147 
flag:= true; 
4111  148 
if not flag then 
149 
begin 

150 
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

151 
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

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

154 
end; 
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset

155 
if tmp > 0 then 
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

156 
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

157 
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

158 
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

159 
end 
3682  160 
end; 
1054  161 

3682  162 
Gear:= Gear^.NextGear 
163 
end; 

1054  164 
end; 
165 

4  166 
procedure ProcessGears; 
7395  167 
var t: PGear; 
4207
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset

168 
i, AliveCount: LongInt; 
3331  169 
s: shortstring; 
9672
8663d299ba62
this should prevent sliding when game clock isn't running. sorry unc0rr, not going to bother encapsulating. maybe later. short on time right now/lazy
nemo
parents:
9651
diff
changeset

170 
prevtime: LongWord; 
4  171 
begin 
9672
8663d299ba62
this should prevent sliding when game clock isn't running. sorry unc0rr, not going to bother encapsulating. maybe later. short on time right now/lazy
nemo
parents:
9651
diff
changeset

172 
prevtime:= TurnTimeLeft; 
8349
a1dbe148f10f
move onNewTurn, onGameTick and onGameTick20 to try and avoid ParseCommand breakage after nextturn call. Needs testing, but should be safe for most scripts. Also fix locale loading.
nemo
parents:
8204
diff
changeset

173 
ScriptCall('onGameTick'); 
a1dbe148f10f
move onNewTurn, onGameTick and onGameTick20 to try and avoid ParseCommand breakage after nextturn call. Needs testing, but should be safe for most scripts. Also fix locale loading.
nemo
parents:
8204
diff
changeset

174 
if GameTicks mod 20 = 0 then ScriptCall('onGameTick20'); 
8351  175 
if GameTicks = NewTurnTick then 
176 
begin 

177 
ScriptCall('onNewTurn'); 

9651  178 
{$IFDEF USE_TOUCH_INTERFACE} 
8351  179 
uTouch.NewTurnBeginning(); 
180 
{$ENDIF} 

181 
end; 

8349
a1dbe148f10f
move onNewTurn, onGameTick and onGameTick20 to try and avoid ParseCommand breakage after nextturn call. Needs testing, but should be safe for most scripts. Also fix locale loading.
nemo
parents:
8204
diff
changeset

182 

868  183 
PrvInactive:= AllInactive; 
4  184 
AllInactive:= true; 
1495  185 

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

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

189 
begin 
7053  190 
StopSoundChan(StepSoundChannel); 
2993
d83edb74e92d
Remove animation on jumping/resuming walk, only leave it in on weapon switch
nemo
parents:
2991
diff
changeset

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

192 
end; 
2940  193 

194 
if StepSoundTimer > 0 then 

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

195 
dec(StepSoundTimer, 1); 
2940  196 

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

199 
begin 
7395  200 
curHandledGear:= t; 
201 
t:= curHandledGear^.NextGear; 

3123  202 

7517  203 
if curHandledGear^.Message and gmDelete <> 0 then 
7519  204 
DeleteGear(curHandledGear) 
205 
else 

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

206 
begin 
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset

207 
if curHandledGear^.Message and gmRemoveFromList <> 0 then 
7519  208 
begin 
209 
RemoveGearFromList(curHandledGear); 

210 
// since I can't think of any good reason this would ever be separate from a remove from list, going to keep it inside this block 

211 
if curHandledGear^.Message and gmAddToList <> 0 then InsertGearToList(curHandledGear); 

212 
curHandledGear^.Message:= curHandledGear^.Message and (not (gmRemoveFromList or gmAddToList)) 

213 
end; 

214 
if curHandledGear^.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

215 
begin 
7519  216 
if curHandledGear^.RenderTimer and (curHandledGear^.Timer > 500) and ((curHandledGear^.Timer mod 1000) = 0) then 
217 
begin 

218 
FreeTexture(curHandledGear^.Tex); 

219 
curHandledGear^.Tex:= RenderStringTex(inttostr(curHandledGear^.Timer div 1000), cWhiteColor, fntSmall); 

220 
end; 

221 
curHandledGear^.doStep(curHandledGear); 

222 
// might be useful later 

223 
//ScriptCall('onGearStep', Gear^.uid); 

224 
end 

2204
526f8165acce
Smaxx' idea of timers, reworked just a tad. Might need variable for offset, but seems ok for now
nemo
parents:
2186
diff
changeset

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

226 
end; 
7395  227 
curHandledGear:= nil; 
89  228 

4  229 
if AllInactive then 
1343  230 
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

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

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

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

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

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

236 
dec(delay); 
614  237 

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

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

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

240 
end; 
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset

241 

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

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

243 
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

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

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

246 
step:= stDelay; 
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset

247 

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

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

249 
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

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

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

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

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

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

255 
inc(step); 
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset

256 

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

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

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

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

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

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

262 
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

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

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

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

266 
end; 
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset

267 

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

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

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

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

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

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

273 
dec(delay); 
815  274 

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

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

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

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

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

279 
begin 
7669
a85e1c167b69
I didn't want to do this since it seems less clean, but...
sheepluva
parents:
7667
diff
changeset

280 
CheckForWin(); 
6580
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 
end; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

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

284 
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

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

286 
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

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

288 
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

289 
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

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

291 
end 
7667
4346566c5a58
skip second CheckForWin if water wasn't raised after first one
sheepluva
parents:
7666
diff
changeset

292 
else // since we are not raising the water, a second wincheck isn't needed 
4346566c5a58
skip second CheckForWin if water wasn't raised after first one
sheepluva
parents:
7666
diff
changeset

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

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

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

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

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

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

299 

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

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

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

302 
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

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

304 
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

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

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

307 
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

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

309 
SuddenDeathDmg:= true; 
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset

310 

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

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

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

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

314 
ScreenFadeSpeed:= 1; 
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset

315 

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

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

317 
ChangeToSDFlakes; 
9295
f8819c3dde54
Remove some GLunit dependencies noticed on graph. uUtils was using it for GLfloat  but, the stuff it was returning to was usually converting to "real" anyway. uLand was including it unnecessarily. Minor refactor
nemo
parents:
9293
diff
changeset

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

319 
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

320 
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

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

322 
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

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

324 
StopMusic //No SDMusic for now 
7021
0c75512a8920
adjust the scope of a few uSound variables and functions
koda
parents:
7010
diff
changeset

325 
//ChangeMusic(SDMusic) 
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

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

327 
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

328 
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

329 
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

330 
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

331 
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

332 
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

333 
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

334 
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

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

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

337 
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

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

339 
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

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

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

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

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

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

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

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

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

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

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

350 
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

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

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

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

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

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

356 
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

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

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

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

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

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

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

363 
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

364 
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

365 
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

366 
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

367 
OnUsedAmmo(CurrentHedgehog^); 
3697  368 

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

369 
EndTurnCleanup; 
2376  370 

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

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

7181
0791c1f2734c
Welp. We have a bit of a problem here. Reverting the move of nextturn. But this causes a desync in scripting unless we can find a better fix.
nemo
parents:
7174
diff
changeset

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

374 
SwitchHedgehog; 
1298  375 

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

376 
AfterSwitchHedgehog; 
8349
a1dbe148f10f
move onNewTurn, onGameTick and onGameTick20 to try and avoid ParseCommand breakage after nextturn call. Needs testing, but should be safe for most scripts. Also fix locale loading.
nemo
parents:
8204
diff
changeset

377 
bBetweenTurns:= false; 
a1dbe148f10f
move onNewTurn, onGameTick and onGameTick20 to try and avoid ParseCommand breakage after nextturn call. Needs testing, but should be safe for most scripts. Also fix locale loading.
nemo
parents:
8204
diff
changeset

378 
NewTurnTick:= GameTicks + 1 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

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

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

381 
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

382 
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

383 
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

384 
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

385 
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

386 
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

387 
else 
3957  388 
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

389 
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

390 

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

391 
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

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

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

394 
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

395 
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

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

397 
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

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

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

400 
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

401 
end; 
3957  402 
if delay2 = 0 then 
403 
begin 

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

404 
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

405 
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

406 
SweepDirty; 
9497  407 
if (CurrentHedgehog^.Gear = nil) or (CurrentHedgehog^.Gear^.State and gstHHDriven = 0) or (CurrentHedgehog^.Gear^.Damage = 0) then 
408 
CheckNoDamage; 

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

409 
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

410 
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

411 
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

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

413 
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

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

415 
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

416 
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

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

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

419 
end 
3957  420 
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

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

422 
end; 
15  423 

4  424 
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

425 
if CurrentHedgehog^.Gear <> nil then 
9573  426 
if (((CurrentHedgehog^.Gear^.State and gstAttacking) = 0) 
9583  427 
or (Ammoz[CurrentHedgehog^.CurAmmoType].Ammo.Propz and ammoprop_DoesntStopTimerWhileAttacking <> 0)) 
9573  428 
and not(isInMultiShoot and ((Ammoz[CurrentHedgehog^.CurAmmoType].Ammo.Propz and ammoprop_DoesntStopTimerInMultiShoot) <> 0)) then 
429 
//(CurrentHedgehog^.CurAmmoType in [amShotgun, amDEagle, amSniperRifle]) 

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

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

431 
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

432 
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

433 
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

434 
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

435 
and ((CurrentHedgehog^.Gear^.State and gstAttacked) = 0) then 
7053  436 
PlaySoundV(sndHurry, CurrentTeam^.voicepack); 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

437 
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

438 
begin 
6596
4c06ea12de1c
Tweak voices a bit (always play hurry at correct time, skip "come on then" if other voice is playing)
nemo
parents:
6580
diff
changeset

439 
if (ReadyTimeLeft = 2000) and (LastVoice.snd = sndNone) then 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

440 
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

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

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

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

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

445 
end; 
351  446 

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

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

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

449 
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

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

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

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

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

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

455 

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

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

458 
if (not CurrentTeam^.ExtDriven) then 
5810  459 
begin 
7068  460 
SendIPC(_S'#'); 
5810  461 
AddFileLog('hiTicks increment message sent') 
462 
end; 

2134  463 

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

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

465 
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

466 
end; 
7407  467 
AddRandomness(CheckSum); 
9672
8663d299ba62
this should prevent sliding when game clock isn't running. sorry unc0rr, not going to bother encapsulating. maybe later. short on time right now/lazy
nemo
parents:
9651
diff
changeset

468 
TurnClockActive:= prevtime <> TurnTimeLeft; 
515  469 
inc(GameTicks) 
4  470 
end; 
471 

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

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

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

475 
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

476 
t: PGear; 
1849  477 
begin 
2221  478 
SpeechText:= ''; // in case it has not been consumed 
2017  479 

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

482 
cGravity:= cMaxWindSpeed * 2; 
4623  483 
cGravityf:= 0.00025 * 2 
484 
end; 

1895  485 

2017  486 
if (GameFlags and gfVampiric) = 0 then 
487 
cVampiric:= false; 

488 

1849  489 
cDamageModifier:= _1; 
1895  490 

491 
if (GameFlags and gfLaserSight) = 0 then 

492 
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

493 

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

494 
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

495 
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

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

497 
if (CurrentTeam <> nil) then 
4099  498 
with CurrentTeam^ do 
499 
for i:= 0 to cMaxHHIndex do 

500 
with Hedgehogs[i] do 

501 
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

502 
(* 
4099  503 
if (SpeechGear <> nil) then 
504 
begin 

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

506 
SpeechGear:= nil 

507 
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

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

509 

4099  510 
if (Gear <> nil) then 
511 
begin 

512 
if (GameFlags and gfInvulnerable) = 0 then 

9685
7d925e82e572
Tweak trophyrace to work better w/ skip (probably, needs testing), drop Invulnerable in favour of effects  heInvulnerable is already in effects,
nemo
parents:
9672
diff
changeset

513 
Gear^.Hedgehog^.Effects[heInvulnerable]:= 0; 
4099  514 
end; 
515 
end; 

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

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

517 
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

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

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

521 
begin 
4372  522 
t^.Health:= t^.Hedgehog^.InitialHealth; 
523 
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

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

525 
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

526 
end; 
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset

527 

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

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

530 

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

532 
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

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

535 

4385  536 
procedure DrawGears; 
537 
var Gear: PGear; 

538 
x, y: LongInt; 

2802  539 
begin 
4385  540 
Gear:= GearsList; 
541 
while Gear <> nil do 

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

542 
begin 
7257
566bdf2f023b
Modified DrawGear so that it doesn't draw the gear when it has message gmRemoveFromList (it was causing havoc when I used HideHog as it could not access the position of the hog)
belphegorr <szabibibi@gmail.com>
parents:
7181
diff
changeset

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

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

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

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

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

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

550 
end; 
2802  551 
end; 
552 

4  553 
procedure FreeGearsList; 
554 
var t, tt: PGear; 

555 
begin 

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

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

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

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

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

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

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

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

563 
end; 
4  564 
end; 
565 

10  566 
procedure AddMiscGears; 
9685
7d925e82e572
Tweak trophyrace to work better w/ skip (probably, needs testing), drop Invulnerable in favour of effects  heInvulnerable is already in effects,
nemo
parents:
9672
diff
changeset

567 
var p,i,j,rx, ry: Longword; 
7406
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset

568 
rdx, rdy: hwFloat; 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

569 
Gear: PGear; 
4  570 
begin 
498  571 
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

572 

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

573 
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

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

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

577 
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

578 
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

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

580 
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

581 

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

582 
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

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

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

586 
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

587 
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

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

589 
end; 
1895  590 

591 
if (GameFlags and gfLowGravity) <> 0 then 

4623  592 
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

593 
cGravity:= cMaxWindSpeed; 
4623  594 
cGravityf:= 0.00025 
595 
end; 

1895  596 

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

599 

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

9685
7d925e82e572
Tweak trophyrace to work better w/ skip (probably, needs testing), drop Invulnerable in favour of effects  heInvulnerable is already in effects,
nemo
parents:
9672
diff
changeset

602 
for p:= 0 to Pred(ClansCount) do 
7d925e82e572
Tweak trophyrace to work better w/ skip (probably, needs testing), drop Invulnerable in favour of effects  heInvulnerable is already in effects,
nemo
parents:
9672
diff
changeset

603 
with ClansArray[p]^ do 
7d925e82e572
Tweak trophyrace to work better w/ skip (probably, needs testing), drop Invulnerable in favour of effects  heInvulnerable is already in effects,
nemo
parents:
9672
diff
changeset

604 
for j:= 0 to Pred(TeamsNumber) do 
7d925e82e572
Tweak trophyrace to work better w/ skip (probably, needs testing), drop Invulnerable in favour of effects  heInvulnerable is already in effects,
nemo
parents:
9672
diff
changeset

605 
with Teams[j]^ do 
7d925e82e572
Tweak trophyrace to work better w/ skip (probably, needs testing), drop Invulnerable in favour of effects  heInvulnerable is already in effects,
nemo
parents:
9672
diff
changeset

606 
for i:= 0 to cMaxHHIndex do 
7d925e82e572
Tweak trophyrace to work better w/ skip (probably, needs testing), drop Invulnerable in favour of effects  heInvulnerable is already in effects,
nemo
parents:
9672
diff
changeset

607 
with Hedgehogs[i] do 
7d925e82e572
Tweak trophyrace to work better w/ skip (probably, needs testing), drop Invulnerable in favour of effects  heInvulnerable is already in effects,
nemo
parents:
9672
diff
changeset

608 
Effects[heInvulnerable]:= 1; 
1895  609 

610 
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

611 
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

612 

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

613 
if (GameFlags and gfArtillery) <> 0 then 
4611  614 
cArtillery:= true; 
8030
165aeaaaf445
Call fallers less often. Should hopefully still be about as effective at the intended purpose. Should help loads quite a bit.
nemo
parents:
8011
diff
changeset

615 
for i:= (LAND_WIDTH*LAND_HEIGHT) div 524288+2 downto 0 do 
7575
f415b3e0f3b9
Burn a random number in the override. Make sure cirbuf is reset.
nemo
parents:
7519
diff
changeset

616 
begin 
f415b3e0f3b9
Burn a random number in the override. Make sure cirbuf is reset.
nemo
parents:
7519
diff
changeset

617 
rx:= GetRandom(rightXleftX)+leftX; 
7406
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset

618 
ry:= GetRandom(LAND_HEIGHTtopY)+topY; 
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset

619 
rdx:= _90(GetRandomf*_360); 
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset

620 
rdy:= _90(GetRandomf*_360); 
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset

621 
AddGear(rx, ry, gtGenericFaller, gstInvisible, rdx, rdy, $FFFFFFFF); 
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset

622 
end; 
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset

623 

7477
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7426
diff
changeset

624 
snowRight:= max(LAND_WIDTH,4096)+512; 
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7426
diff
changeset

625 
snowLeft:= (snowRightLAND_WIDTH); 
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7426
diff
changeset

626 

9768
08799c901a42
Add rubber utility. Graphics are still incomplete. Also flag snow/ice in theme config.
nemo
parents:
9764
diff
changeset

627 
if (not hasBorder) and cSnow then 
7721  628 
for i:= vobCount * Longword(max(LAND_WIDTH,4096)) div 2048 downto 1 do 
9951
b776cd642d0b
pick random x/y prior to addgear (as generic faller does) to avoid random numbers picked out of order
nemo
parents:
9818
diff
changeset

629 
begin 
b776cd642d0b
pick random x/y prior to addgear (as generic faller does) to avoid random numbers picked out of order
nemo
parents:
9818
diff
changeset

630 
rx:=GetRandom(snowRight  snowLeft); 
b776cd642d0b
pick random x/y prior to addgear (as generic faller does) to avoid random numbers picked out of order
nemo
parents:
9818
diff
changeset

631 
ry:=GetRandom(750); 
b776cd642d0b
pick random x/y prior to addgear (as generic faller does) to avoid random numbers picked out of order
nemo
parents:
9818
diff
changeset

632 
AddGear(rx + snowLeft, LAND_HEIGHT + ry  1300, gtFlake, 0, _0, _0, 0) 
b776cd642d0b
pick random x/y prior to addgear (as generic faller does) to avoid random numbers picked out of order
nemo
parents:
9818
diff
changeset

633 
end 
4  634 
end; 
635 

636 
procedure AssignHHCoords; 

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

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

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

641 
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

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

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

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

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

646 
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

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

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

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

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

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

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

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

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

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

656 
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

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

658 
else 
7174
80480d21e6ed
Workaround for bug #144. This workaround had occurred to me a while ago, but wasn't sure if placing them unfairly was better than not placing them at all. Argument for not placing at all is people should probably abort the game when they notice it. Argument for placing unfairly is people can still abort, and if we really wanted them to abort, we should probably just have halted launch if all hogs failed to spawn. This way at least play can continue.
nemo
parents:
7165
diff
changeset

659 
FindPlace(Gear, false, t, t + LAND_WIDTH div 2, true);// could make Gear == nil; 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

684 
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

685 
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

686 
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

687 
else 
7174
80480d21e6ed
Workaround for bug #144. This workaround had occurred to me a while ago, but wasn't sure if placing them unfairly was better than not placing them at all. Argument for not placing at all is people should probably abort the game when they notice it. Argument for placing unfairly is people can still abort, and if we really wanted them to abort, we should probably just have halted launch if all hogs failed to spawn. This way at least play can continue.
nemo
parents:
7165
diff
changeset

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

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

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

691 
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

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

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

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

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

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

697 
end 
4  698 
end; 
699 

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

700 

1433  701 
{procedure AmmoFlameWork(Ammo: PGear); 
79  702 
var t: PGear; 
703 
begin 

704 
t:= GearsList; 

705 
while t <> nil do 

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

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

707 
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

708 
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

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

711 
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

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

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

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

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

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

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

718 
end; 
1433  719 
end;} 
79  720 

16  721 

7337
c224cd2d32f3
Allow script to set number of ammo in a crate. untested.
nemo
parents:
7335
diff
changeset

722 
function SpawnCustomCrateAt(x, y: LongInt; crate: TCrateType; content, cnt: Longword): PGear; 
3730  723 
begin 
3734  724 
FollowGear := AddGear(x, y, gtCase, 0, _0, _0, 0); 
725 
cCaseFactor := 0; 

726 

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

727 
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

728 
content := ord(High(TAmmoType)); 
3734  729 

7337
c224cd2d32f3
Allow script to set number of ammo in a crate. untested.
nemo
parents:
7335
diff
changeset

730 
FollowGear^.Power:= cnt; 
c224cd2d32f3
Allow script to set number of ammo in a crate. untested.
nemo
parents:
7335
diff
changeset

731 

3734  732 
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

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

734 
begin 
3734  735 
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

736 
FollowGear^.Health := content; 
3734  737 
AddCaption(GetEventString(eidNewHealthPack), cWhiteColor, capgrpAmmoInfo); 
738 
end; 

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

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

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

742 
FollowGear^.AmmoType := TAmmoType(content); 
3734  743 
AddCaption(GetEventString(eidNewAmmoPack), cWhiteColor, capgrpAmmoInfo); 
744 
end; 

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

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

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

748 
FollowGear^.AmmoType := TAmmoType(content); 
3734  749 
AddCaption(GetEventString(eidNewUtilityPack), cWhiteColor, capgrpAmmoInfo); 
750 
end; 

751 
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

752 

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

753 
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

754 
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

755 

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

756 
SpawnCustomCrateAt := FollowGear; 
3730  757 
end; 
758 

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

760 
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

761 
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

762 
cCaseFactor := 0; 
5343  763 
FollowGear^.Pos := posCaseDummy; 
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset

764 

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

765 
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

766 
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

767 
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

768 
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

769 

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

770 
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

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

772 
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

773 
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

774 
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

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

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

777 
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

778 
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

779 
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

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

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

782 
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

783 
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

784 
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

785 
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

786 
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

787 

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

788 
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

789 
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

790 

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

791 
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

792 
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

793 

2726  794 

2790  795 
function GearByUID(uid : Longword) : PGear; 
796 
var gear: PGear; 

797 
begin 

798 
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

799 
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

800 
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

801 
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

802 
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

803 
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

804 
end; 
2790  805 
gear:= GearsList; 
806 
while gear <> nil do 

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

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

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

809 
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

810 
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

811 
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

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

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

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

815 
end 
2790  816 
end; 
817 

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

818 

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

819 
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

820 
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

821 
s:= s; // avoid compiler hint 
7805  822 
if not isExternalSource then 
7068  823 
SendIPC(_S','); 
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

824 
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

825 
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

826 
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

827 

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

828 
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

829 
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

830 
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

831 
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

832 
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

833 
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

834 
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

835 
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

836 
i:= 0; 
4469  837 
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

838 
x:= byte(s[1]); // speech type 
4469  839 
if x < 4 then 
840 
begin 

841 
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

842 
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

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

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

846 
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

847 
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

848 
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

849 
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

850 
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

851 
text:= copy(s, 3, Length(s)  1) 
4468  852 
else text:= copy(s, 2, Length(s)  1); 
853 

9818  854 
if text = '' then text:= '...'; 
855 

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

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

857 
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

858 
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

859 
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

860 
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

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

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

863 

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

864 
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

865 
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

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

867 
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

868 
hh:= CurrentHedgehog 
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset

869 
else 
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

870 
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

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

872 
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

873 
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

874 
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

875 
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

876 
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

877 
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

878 
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

879 
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

880 
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

881 
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

882 
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

883 
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

884 
end; 
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset

885 
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

886 
begin 
4784  887 
Gear:= AddVisualGear(0, 0, vgtSpeechBubble); 
888 
if Gear <> nil then 

889 
begin 

890 
Gear^.Hedgehog:= hh; 

891 
Gear^.Text:= text; 

892 
Gear^.FrameTicks:= x 

9764
8dc9d268330f
revert r938d1c08d0d1 in favour of putting it in the chat log. I think this addresses main concern about missing text. There've been complaints in past too about conversation in bubbles not being visible in history. If the objection is that r938d1c08d0d1 offers a more Ã¦sthetic solution, I think it should augment this, be flagged, and fix the visual issues first.
nemo
parents:
9685
diff
changeset

893 
end; 
9777  894 
//ParseCommand('/say [' + hh^.Name + '] '+text, true) 
9779  895 
AddChatString(#1+'[' + HH^.Name + '] '+text); 
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

896 
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

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

898 
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

899 
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

900 
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

901 
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

902 
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

903 
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

904 

3038  905 
procedure initModule; 
6543  906 
const handlers: array[TGearType] of TGearStepProcedure = ( 
6890  907 
@doStepFlame, 
908 
@doStepHedgehog, 

909 
@doStepMine, 

910 
@doStepCase, 

911 
@doStepCase, 

6543  912 
@doStepBomb, 
913 
@doStepShell, 

914 
@doStepGrave, 

915 
@doStepBee, 

916 
@doStepShotgunShot, 

917 
@doStepPickHammer, 

918 
@doStepRope, 

919 
@doStepDEagleShot, 

920 
@doStepDynamite, 

921 
@doStepBomb, 

922 
@doStepCluster, 

923 
@doStepShover, 

924 
@doStepFirePunch, 

925 
@doStepActionTimer, 

926 
@doStepActionTimer, 

927 
@doStepParachute, 

928 
@doStepAirAttack, 

929 
@doStepAirBomb, 

930 
@doStepBlowTorch, 

931 
@doStepGirder, 

932 
@doStepTeleport, 

933 
@doStepSwitcher, 

934 
@doStepTarget, 

935 
@doStepMortar, 

936 
@doStepWhip, 

937 
@doStepKamikaze, 

938 
@doStepCake, 

939 
@doStepSeduction, 

940 
@doStepBomb, 

941 
@doStepCluster, 

942 
@doStepBomb, 

943 
@doStepWaterUp, 

944 
@doStepDrill, 

945 
@doStepBallgun, 

946 
@doStepBomb, 

947 
@doStepRCPlane, 

948 
@doStepSniperRifleShot, 

949 
@doStepJetpack, 

950 
@doStepMolotov, 

951 
@doStepBirdy, 

952 
@doStepEggWork, 

953 
@doStepPortalShot, 

954 
@doStepPiano, 

955 
@doStepBomb, 

956 
@doStepSineGunShot, 

957 
@doStepFlamethrower, 

958 
@doStepSMine, 

959 
@doStepPoisonCloud, 

960 
@doStepHammer, 

961 
@doStepHammerHit, 

962 
@doStepResurrector, 

963 
@doStepNapalmBomb, 

964 
@doStepSnowball, 

965 
@doStepSnowflake, 

8161  966 
//@doStepStructure, 
6543  967 
@doStepLandGun, 
7007  968 
@doStepTardis, 
7389
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7370
diff
changeset

969 
@doStepIceGun, 
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7370
diff
changeset

970 
@doStepAddAmmo, 
7730
2013733f9ca9
A bit more on the knife. Also add missing files to CMakeLists
nemo
parents:
7721
diff
changeset

971 
@doStepGenericFaller, 
2013733f9ca9
A bit more on the knife. Also add missing files to CMakeLists
nemo
parents:
7721
diff
changeset

972 
@doStepKnife); 
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset

973 
begin 
6543  974 
doStepHandlers:= handlers; 
975 

6898  976 
RegisterVariable('skip', @chSkip, false); 
977 
RegisterVariable('hogsay', @chHogSay, 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

978 

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

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

980 
GearsList:= nil; 
7395  981 
curHandledGear:= nil; 
982 

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

983 
KilledHHs:= 0; 
4792
68f9b331014a
sudden death changes: only change visual bit on health decrease and support for water transparancy change and clouds number change
Henek
parents:
4790
diff
changeset

984 
SuddenDeath:= false; 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2947
diff
changeset

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

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

987 
skipFlag:= false; 
3697  988 

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

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

990 
PrvInactive:= false; 
6982  991 

992 
//typed const 

993 
delay:= 0; 

994 
delay2:= 0; 

995 
step:= stDelay; 

996 
upd:= 0; 

7021
0c75512a8920
adjust the scope of a few uSound variables and functions
koda
parents:
7010
diff
changeset

997 

0c75512a8920
adjust the scope of a few uSound variables and functions
koda
parents:
7010
diff
changeset

998 
//SDMusic:= 'hell.ogg'; 
8349
a1dbe148f10f
move onNewTurn, onGameTick and onGameTick20 to try and avoid ParseCommand breakage after nextturn call. Needs testing, but should be safe for most scripts. Also fix locale loading.
nemo
parents:
8204
diff
changeset

999 
NewTurnTick:= $FFFFFFFF; 
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset

1000 
end; 
4  1001 

3038  1002 
procedure freeModule; 
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset

1003 
begin 
3615  1004 
FreeGearsList(); 
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset

1005 
end; 
4  1006 

2451
5affd0840927
New data files from Tiy, add gtFlame to avoidance list
nemo
parents:
2428
diff
changeset

1007 
end. 