author  Wuzzy <Wuzzy2@mail.ru> 
Wed, 11 Jul 2018 21:56:30 +0200  
changeset 13476  c265a3e6f6da 
parent 13452  2d787d122083 
child 13499  c41b16ac2e05 
permissions  rwrr 
9285  1 
(* 
1066  2 
* Hedgewars, a free turn based strategy game 
11046  3 
* Copyright (c) 20042015 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 

10108
c68cf030eded
update FSF address. note: two sdl include files (by Sam Lantinga) still have the old FSF address in their copyright  but I ain't gonna touch their copyright headers
sheepluva
parents:
10105
diff
changeset

16 
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 021101301 USA 
4  17 
*) 
18 

2599  19 
{$INCLUDE "options.inc"} 
2587
0dfa56a8513c
fix a segfault in the iphone simulator by moving options.inc at the beginning of the file
koda
parents:
2586
diff
changeset

20 

4  21 
unit uTeams; 
22 
interface 

10015  23 
uses uConsts, uInputHandler, uRandom, uFloat, uStats, 
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:
9291
diff
changeset

24 
uCollisions, uSound, uStore, uTypes, uScript 
7837  25 
{$IFDEF USE_TOUCH_INTERFACE}, uWorld{$ENDIF}; 
26 

534  27 

3038  28 
procedure initModule; 
29 
procedure freeModule; 

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:
4393
diff
changeset

30 

1058
c53c5c4e7b48
 Proper turns counting, split SwitchHedgehog into two functions
unc0rr
parents:
1011
diff
changeset

31 
function AddTeam(TeamColor: Longword): PTeam; 
4  32 
procedure SwitchHedgehog; 
1058
c53c5c4e7b48
 Proper turns counting, split SwitchHedgehog into two functions
unc0rr
parents:
1011
diff
changeset

33 
procedure AfterSwitchHedgehog; 
4  34 
procedure InitTeams; 
35 
function TeamSize(p: PTeam): Longword; 

47  36 
procedure RecountTeamHealth(team: PTeam); 
10581  37 
procedure RecountAllTeamsHealth(); 
8817
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset

38 
procedure RestoreHog(HH: PHedgehog); 
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset

39 

72  40 
procedure RestoreTeamsFromSave; 
1058
c53c5c4e7b48
 Proper turns counting, split SwitchHedgehog into two functions
unc0rr
parents:
1011
diff
changeset

41 
function CheckForWin: boolean; 
2040  42 
procedure TeamGoneEffect(var Team: TTeam); 
7270
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset

43 
procedure SwitchCurrentHedgehog(newHog: PHedgehog); 
4  44 

9720
453a1c29b7e4
Animate hedgehogs healths inside team health bar. Proper animation for the case when max team health grows is lost though.
unc0rr
parents:
9685
diff
changeset

45 
var MaxTeamHealth: LongInt; 
453a1c29b7e4
Animate hedgehogs healths inside team health bar. Proper animation for the case when max team health grows is lost though.
unc0rr
parents:
9685
diff
changeset

46 

4  47 
implementation 
8370  48 
uses uLocale, uAmmos, uChat, uVariables, uUtils, uIO, uCaptions, uCommands, uDebug, 
9468
3d07fd84c39d
 Actually call uTexture.initModule and .freeModule
unc0rr
parents:
9466
diff
changeset

49 
uGearsUtils, uGearsList, uVisualGearsList, uTextures 
7837  50 
{$IFDEF USE_TOUCH_INTERFACE}, uTouch{$ENDIF}; 
4377  51 

12322
9aa483762025
Fix sndBoring being played when forceending turn due to victory
Wuzzy <almikes@aol.com>
parents:
12276
diff
changeset

52 
var TeamsGameOver: boolean; 
8145
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
8054
diff
changeset

53 
NextClan: boolean; 
4  54 

92
0c359a7a2356
 Fix win message to appear only after all hedgehogs death
unc0rr
parents:
89
diff
changeset

55 
function CheckForWin: boolean; 
576  56 
var AliveClan: PClan; 
13047
eadf8259306f
Improve/fix messaging when multiple teams win
Wuzzy <Wuzzy2@mail.ru>
parents:
13018
diff
changeset

57 
s, cap: ansistring; 
eadf8259306f
Improve/fix messaging when multiple teams win
Wuzzy <Wuzzy2@mail.ru>
parents:
13018
diff
changeset

58 
ts: array[0..(cMaxTeams  1)] of ansistring; 
1011  59 
t, AliveCount, i, j: LongInt; 
83  60 
begin 
6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset

61 
CheckForWin:= false; 
548  62 
AliveCount:= 0; 
549  63 
for t:= 0 to Pred(ClansCount) do 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2905
diff
changeset

64 
if ClansArray[t]^.ClanHealth > 0 then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2905
diff
changeset

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

66 
inc(AliveCount); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2905
diff
changeset

67 
AliveClan:= ClansArray[t] 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2905
diff
changeset

68 
end; 
548  69 

6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset

70 
if (AliveCount > 1) or ((AliveCount = 1) and ((GameFlags and gfOneClanMode) <> 0)) then 
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset

71 
exit; 
351  72 
CheckForWin:= true; 
83  73 

74 
TurnTimeLeft:= 0; 

3774  75 
ReadyTimeLeft:= 0; 
7669
a85e1c167b69
I didn't want to do this since it seems less clean, but...
sheepluva
parents:
7442
diff
changeset

76 

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

77 
// if the game ends during a multishot, do last TurnReaction 
a85e1c167b69
I didn't want to do this since it seems less clean, but...
sheepluva
parents:
7442
diff
changeset

78 
if (not bBetweenTurns) and isInMultiShoot then 
a85e1c167b69
I didn't want to do this since it seems less clean, but...
sheepluva
parents:
7442
diff
changeset

79 
TurnReaction(); 
a85e1c167b69
I didn't want to do this since it seems less clean, but...
sheepluva
parents:
7442
diff
changeset

80 

12322
9aa483762025
Fix sndBoring being played when forceending turn due to victory
Wuzzy <almikes@aol.com>
parents:
12276
diff
changeset

81 
if not TeamsGameOver then 
4014
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset

82 
begin 
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset

83 
if AliveCount = 0 then 
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset

84 
begin // draw 
12172
fe2946e2a859
Implement random round draw / team win messages
Wuzzy <almikes@aol.com>
parents:
11913
diff
changeset

85 
AddCaption(GetEventString(eidRoundDraw), cWhiteColor, capgrpGameState); 
12332
657a8d63c99d
Lua API: SendAchevementsStatsOff, SendGameResultOff, SendRankingStatsOff
Wuzzy <almikes@aol.com>
parents:
12322
diff
changeset

86 
if SendGameResultOn then 
657a8d63c99d
Lua API: SendAchevementsStatsOff, SendGameResultOff, SendRankingStatsOff
Wuzzy <almikes@aol.com>
parents:
12322
diff
changeset

87 
SendStat(siGameResult, shortstring(trmsg[sidDraw])); 
12172
fe2946e2a859
Implement random round draw / team win messages
Wuzzy <almikes@aol.com>
parents:
11913
diff
changeset

88 
AddGear(0, 0, gtATFinishGame, 0, _0, _0, 3000); 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

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

90 
else // win 
12579
0411e04cf12a
Fix stats screen caption showing only one winner if multiple teams have won
Wuzzy <almikes@aol.com>
parents:
12410
diff
changeset

91 
begin 
4014
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset

92 
with AliveClan^ do 
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset

93 
begin 
13047
eadf8259306f
Improve/fix messaging when multiple teams win
Wuzzy <Wuzzy2@mail.ru>
parents:
13018
diff
changeset

94 
if TeamsNumber = 1 then // single team wins 
12172
fe2946e2a859
Implement random round draw / team win messages
Wuzzy <almikes@aol.com>
parents:
11913
diff
changeset

95 
begin 
13047
eadf8259306f
Improve/fix messaging when multiple teams win
Wuzzy <Wuzzy2@mail.ru>
parents:
13018
diff
changeset

96 
s:= ansistring(Teams[0]^.TeamName); 
eadf8259306f
Improve/fix messaging when multiple teams win
Wuzzy <Wuzzy2@mail.ru>
parents:
13018
diff
changeset

97 
// Victory caption is randomly selected 
eadf8259306f
Improve/fix messaging when multiple teams win
Wuzzy <Wuzzy2@mail.ru>
parents:
13018
diff
changeset

98 
cap:= FormatA(GetEventString(eidRoundWin), s); 
12579
0411e04cf12a
Fix stats screen caption showing only one winner if multiple teams have won
Wuzzy <almikes@aol.com>
parents:
12410
diff
changeset

99 
AddCaption(cap, cWhiteColor, capgrpGameState); 
13047
eadf8259306f
Improve/fix messaging when multiple teams win
Wuzzy <Wuzzy2@mail.ru>
parents:
13018
diff
changeset

100 
s:= FormatA(trmsg[sidWinner], s); 
12172
fe2946e2a859
Implement random round draw / team win messages
Wuzzy <almikes@aol.com>
parents:
11913
diff
changeset

101 
end 
13047
eadf8259306f
Improve/fix messaging when multiple teams win
Wuzzy <Wuzzy2@mail.ru>
parents:
13018
diff
changeset

102 
else // clan with at least 2 teams wins 
12172
fe2946e2a859
Implement random round draw / team win messages
Wuzzy <almikes@aol.com>
parents:
11913
diff
changeset

103 
begin 
12579
0411e04cf12a
Fix stats screen caption showing only one winner if multiple teams have won
Wuzzy <almikes@aol.com>
parents:
12410
diff
changeset

104 
s:= ''; 
0411e04cf12a
Fix stats screen caption showing only one winner if multiple teams have won
Wuzzy <almikes@aol.com>
parents:
12410
diff
changeset

105 
for j:= 0 to Pred(TeamsNumber) do 
0411e04cf12a
Fix stats screen caption showing only one winner if multiple teams have won
Wuzzy <almikes@aol.com>
parents:
12410
diff
changeset

106 
begin 
13047
eadf8259306f
Improve/fix messaging when multiple teams win
Wuzzy <Wuzzy2@mail.ru>
parents:
13018
diff
changeset

107 
ts[j] := Teams[j]^.TeamName; 
eadf8259306f
Improve/fix messaging when multiple teams win
Wuzzy <Wuzzy2@mail.ru>
parents:
13018
diff
changeset

108 
end; 
12579
0411e04cf12a
Fix stats screen caption showing only one winner if multiple teams have won
Wuzzy <almikes@aol.com>
parents:
12410
diff
changeset

109 

13047
eadf8259306f
Improve/fix messaging when multiple teams win
Wuzzy <Wuzzy2@mail.ru>
parents:
13018
diff
changeset

110 
// Write victory message for caption and stats page 
eadf8259306f
Improve/fix messaging when multiple teams win
Wuzzy <Wuzzy2@mail.ru>
parents:
13018
diff
changeset

111 
if (TeamsNumber = cMaxTeams) or (TeamsCount = TeamsNumber) then 
eadf8259306f
Improve/fix messaging when multiple teams win
Wuzzy <Wuzzy2@mail.ru>
parents:
13018
diff
changeset

112 
// No enemies for some reason â€¦ Everyone wins!!1! 
eadf8259306f
Improve/fix messaging when multiple teams win
Wuzzy <Wuzzy2@mail.ru>
parents:
13018
diff
changeset

113 
s:= trmsg[sidWinnerAll] 
eadf8259306f
Improve/fix messaging when multiple teams win
Wuzzy <Wuzzy2@mail.ru>
parents:
13018
diff
changeset

114 
else if (TeamsNumber >= 2) and (TeamsNumber < cMaxTeams) then 
eadf8259306f
Improve/fix messaging when multiple teams win
Wuzzy <Wuzzy2@mail.ru>
parents:
13018
diff
changeset

115 
// List all winning teams in a list 
eadf8259306f
Improve/fix messaging when multiple teams win
Wuzzy <Wuzzy2@mail.ru>
parents:
13018
diff
changeset

116 
s:= FormatA(trmsg[TMsgStrId(Ord(sidWinner2) + (TeamsNumber  2))], ts); 
12579
0411e04cf12a
Fix stats screen caption showing only one winner if multiple teams have won
Wuzzy <almikes@aol.com>
parents:
12410
diff
changeset

117 

13047
eadf8259306f
Improve/fix messaging when multiple teams win
Wuzzy <Wuzzy2@mail.ru>
parents:
13018
diff
changeset

118 
// The winner caption is the same as the stats message and not randomized 
eadf8259306f
Improve/fix messaging when multiple teams win
Wuzzy <Wuzzy2@mail.ru>
parents:
13018
diff
changeset

119 
cap:= s; 
eadf8259306f
Improve/fix messaging when multiple teams win
Wuzzy <Wuzzy2@mail.ru>
parents:
13018
diff
changeset

120 
AddCaption(cap, cWhiteColor, capgrpGameState); 
eadf8259306f
Improve/fix messaging when multiple teams win
Wuzzy <Wuzzy2@mail.ru>
parents:
13018
diff
changeset

121 
// TODO (maybe): Show victory animation/captions perteam instead of all winners at once? 
12172
fe2946e2a859
Implement random round draw / team win messages
Wuzzy <almikes@aol.com>
parents:
11913
diff
changeset

122 
end; 
549  123 

4014
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset

124 
for j:= 0 to Pred(TeamsNumber) do 
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset

125 
with Teams[j]^ do 
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset

126 
for i:= 0 to cMaxHHIndex do 
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset

127 
with Hedgehogs[i] do 
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset

128 
if (Gear <> nil) then 
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset

129 
Gear^.State:= gstWinner; 
4978  130 
if Flawless then 
9157
2f8b60b89121
ok. this could be tidier, but, I'm sick of hogs w/ unmodified thaw thawing on exactly wrong turn.
nemo
parents:
9137
diff
changeset

131 
AddVoice(sndFlawless, Teams[0]^.voicepack) 
4978  132 
else 
5638
e35ba2a400d8
Try to avoid overlapping voices for major statements (not things like byebye or oof)
nemo
parents:
5357
diff
changeset

133 
AddVoice(sndVictory, Teams[0]^.voicepack); 
12579
0411e04cf12a
Fix stats screen caption showing only one winner if multiple teams have won
Wuzzy <almikes@aol.com>
parents:
12410
diff
changeset

134 
end; 
2376  135 

12579
0411e04cf12a
Fix stats screen caption showing only one winner if multiple teams have won
Wuzzy <almikes@aol.com>
parents:
12410
diff
changeset

136 
if SendGameResultOn then 
0411e04cf12a
Fix stats screen caption showing only one winner if multiple teams have won
Wuzzy <almikes@aol.com>
parents:
12410
diff
changeset

137 
SendStat(siGameResult, shortstring(s)); 
0411e04cf12a
Fix stats screen caption showing only one winner if multiple teams have won
Wuzzy <almikes@aol.com>
parents:
12410
diff
changeset

138 
AddGear(0, 0, gtATFinishGame, 0, _0, _0, 3000) 
0411e04cf12a
Fix stats screen caption showing only one winner if multiple teams have won
Wuzzy <almikes@aol.com>
parents:
12410
diff
changeset

139 
end; 
4014
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset

140 
SendStats; 
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset

141 
end; 
12322
9aa483762025
Fix sndBoring being played when forceending turn due to victory
Wuzzy <almikes@aol.com>
parents:
12276
diff
changeset

142 
TeamsGameOver:= true; 
4014
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset

143 
GameOver:= true 
83  144 
end; 
145 

4  146 
procedure SwitchHedgehog; 
9137
d987230b85ed
fixed all engine compilation hints and notes (that I could see)
sheepluva
parents:
9080
diff
changeset

147 
var c, i, t: LongWord; 
5052  148 
PrevHH, PrevTeam : LongWord; 
4  149 
begin 
150 
TargetPoint.X:= NoPointX; 

11532  151 
if checkFails(CurrentTeam <> nil, 'nil Team', true) then exit; 
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2758
diff
changeset

152 
with CurrentHedgehog^ do 
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2758
diff
changeset

153 
if (PreviousTeam <> nil) and PlacingHogs and Unplaced then 
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2758
diff
changeset

154 
begin 
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2758
diff
changeset

155 
Unplaced:= false; 
3697  156 
if Gear <> nil then 
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2758
diff
changeset

157 
begin 
2763
f21d3ca74ef2
Do CI correctly. Still need to allow for mode in case of no teleports in ammo
nemo
parents:
2762
diff
changeset

158 
DeleteCI(Gear); 
11471  159 
FindPlace(Gear, false, 0, LAND_WIDTH, true); 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

160 
if Gear <> nil then 
9291
15f7bb217b66
Make add/delete consistent (this has bugged me for so long)
nemo
parents:
9285
diff
changeset

161 
AddCI(Gear) 
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2758
diff
changeset

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

163 
end; 
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2758
diff
changeset

164 

1678  165 
PreviousTeam:= CurrentTeam; 
547  166 

944  167 
with CurrentHedgehog^ do 
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2758
diff
changeset

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

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

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

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

172 
Gear^.Message:= 0; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2905
diff
changeset

173 
Gear^.Z:= cHHZ; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2905
diff
changeset

174 
RemoveGearFromList(Gear); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2905
diff
changeset

175 
InsertGearToList(Gear) 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2905
diff
changeset

176 
end 
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2758
diff
changeset

177 
end; 
4391
de9e1a5102b4
In the case of perhogammo, switch the ammo viewed when not your turn to what will probably be your ammo, assuming that hog survives.
nemo
parents:
4377
diff
changeset

178 
// Try to make the ammo menu viewed when not your turn be a bit more useful for perhogammo mode 
de9e1a5102b4
In the case of perhogammo, switch the ammo viewed when not your turn to what will probably be your ammo, assuming that hog survives.
nemo
parents:
4377
diff
changeset

179 
with CurrentTeam^ do 
de9e1a5102b4
In the case of perhogammo, switch the ammo viewed when not your turn to what will probably be your ammo, assuming that hog survives.
nemo
parents:
4377
diff
changeset

180 
if ((GameFlags and gfPerHogAmmo) <> 0) and (not ExtDriven) and (CurrentHedgehog^.BotLevel = 0) then 
de9e1a5102b4
In the case of perhogammo, switch the ammo viewed when not your turn to what will probably be your ammo, assuming that hog survives.
nemo
parents:
4377
diff
changeset

181 
begin 
de9e1a5102b4
In the case of perhogammo, switch the ammo viewed when not your turn to what will probably be your ammo, assuming that hog survives.
nemo
parents:
4377
diff
changeset

182 
c:= CurrHedgehog; 
de9e1a5102b4
In the case of perhogammo, switch the ammo viewed when not your turn to what will probably be your ammo, assuming that hog survives.
nemo
parents:
4377
diff
changeset

183 
repeat 
de9e1a5102b4
In the case of perhogammo, switch the ammo viewed when not your turn to what will probably be your ammo, assuming that hog survives.
nemo
parents:
4377
diff
changeset

184 
begin 
de9e1a5102b4
In the case of perhogammo, switch the ammo viewed when not your turn to what will probably be your ammo, assuming that hog survives.
nemo
parents:
4377
diff
changeset

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

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

187 
c:= 0 
4391
de9e1a5102b4
In the case of perhogammo, switch the ammo viewed when not your turn to what will probably be your ammo, assuming that hog survives.
nemo
parents:
4377
diff
changeset

188 
end 
10193
d7cd5b43588f
By request. Allow lua to make random things "talk". I'm not sure if this is a good idea, buuuut.
nemo
parents:
10124
diff
changeset

189 
until (c = CurrHedgehog) or (Hedgehogs[c].Gear <> nil) and (Hedgehogs[c].Effects[heFrozen] < 50255); 
4391
de9e1a5102b4
In the case of perhogammo, switch the ammo viewed when not your turn to what will probably be your ammo, assuming that hog survives.
nemo
parents:
4377
diff
changeset

190 
LocalAmmo:= Hedgehogs[c].AmmoStore 
de9e1a5102b4
In the case of perhogammo, switch the ammo viewed when not your turn to what will probably be your ammo, assuming that hog survives.
nemo
parents:
4377
diff
changeset

191 
end; 
4  192 

550  193 
c:= CurrentTeam^.Clan^.ClanIndex; 
4  194 
repeat 
5021  195 
with ClansArray[c]^ do 
12919
0f02dd1ff4c9
Fix TotalRounds counting rounds a couple of turns too late
Wuzzy <Wuzzy2@mail.ru>
parents:
12579
diff
changeset

196 
if (GameFlags and gfTagTeam) <> 0 then 
5021  197 
begin 
12919
0f02dd1ff4c9
Fix TotalRounds counting rounds a couple of turns too late
Wuzzy <Wuzzy2@mail.ru>
parents:
12579
diff
changeset

198 
if (CurrTeam = TagTeamIndex) then 
0f02dd1ff4c9
Fix TotalRounds counting rounds a couple of turns too late
Wuzzy <Wuzzy2@mail.ru>
parents:
12579
diff
changeset

199 
begin 
0f02dd1ff4c9
Fix TotalRounds counting rounds a couple of turns too late
Wuzzy <Wuzzy2@mail.ru>
parents:
12579
diff
changeset

200 
if (c = 0) and (not PlacingHogs) then 
0f02dd1ff4c9
Fix TotalRounds counting rounds a couple of turns too late
Wuzzy <Wuzzy2@mail.ru>
parents:
12579
diff
changeset

201 
inc(TotalRounds); 
0f02dd1ff4c9
Fix TotalRounds counting rounds a couple of turns too late
Wuzzy <Wuzzy2@mail.ru>
parents:
12579
diff
changeset

202 
TagTeamIndex:= Pred(TagTeamIndex) mod TeamsNumber; 
0f02dd1ff4c9
Fix TotalRounds counting rounds a couple of turns too late
Wuzzy <Wuzzy2@mail.ru>
parents:
12579
diff
changeset

203 
CurrTeam:= Pred(CurrTeam) mod TeamsNumber; 
0f02dd1ff4c9
Fix TotalRounds counting rounds a couple of turns too late
Wuzzy <Wuzzy2@mail.ru>
parents:
12579
diff
changeset

204 
inc(c); 
0f02dd1ff4c9
Fix TotalRounds counting rounds a couple of turns too late
Wuzzy <Wuzzy2@mail.ru>
parents:
12579
diff
changeset

205 
NextClan:= true; 
0f02dd1ff4c9
Fix TotalRounds counting rounds a couple of turns too late
Wuzzy <Wuzzy2@mail.ru>
parents:
12579
diff
changeset

206 
end; 
0f02dd1ff4c9
Fix TotalRounds counting rounds a couple of turns too late
Wuzzy <Wuzzy2@mail.ru>
parents:
12579
diff
changeset

207 
end 
0f02dd1ff4c9
Fix TotalRounds counting rounds a couple of turns too late
Wuzzy <Wuzzy2@mail.ru>
parents:
12579
diff
changeset

208 
else if (c = 0) and (not PlacingHogs) then 
0f02dd1ff4c9
Fix TotalRounds counting rounds a couple of turns too late
Wuzzy <Wuzzy2@mail.ru>
parents:
12579
diff
changeset

209 
inc(TotalRounds); 
5021  210 

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

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

212 
inc(c); 
5016
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset

213 

5021  214 
if c = ClansCount then 
12919
0f02dd1ff4c9
Fix TotalRounds counting rounds a couple of turns too late
Wuzzy <Wuzzy2@mail.ru>
parents:
12579
diff
changeset

215 
c:= 0; 
1058
c53c5c4e7b48
 Proper turns counting, split SwitchHedgehog into two functions
unc0rr
parents:
1011
diff
changeset

216 

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

217 
with ClansArray[c]^ do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2905
diff
changeset

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

219 
PrevTeam:= CurrTeam; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2905
diff
changeset

220 
repeat 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2905
diff
changeset

221 
CurrTeam:= Succ(CurrTeam) mod TeamsNumber; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2905
diff
changeset

222 
CurrentTeam:= Teams[CurrTeam]; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2905
diff
changeset

223 
with CurrentTeam^ do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2905
diff
changeset

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

225 
PrevHH:= CurrHedgehog mod HedgehogsNumber; // prevent infinite loop when CurrHedgehog = 7, but HedgehogsNumber < 8 (team is destroyed before its first turn) 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2905
diff
changeset

226 
repeat 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2905
diff
changeset

227 
CurrHedgehog:= Succ(CurrHedgehog) mod HedgehogsNumber; 
9067  228 
until ((Hedgehogs[CurrHedgehog].Gear <> nil) and (Hedgehogs[CurrHedgehog].Effects[heFrozen] < 256)) or (CurrHedgehog = PrevHH) 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2905
diff
changeset

229 
end 
9157
2f8b60b89121
ok. this could be tidier, but, I'm sick of hogs w/ unmodified thaw thawing on exactly wrong turn.
nemo
parents:
9137
diff
changeset

230 
until ((CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog].Gear <> nil) and (CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog].Effects[heFrozen] < 256)) or (PrevTeam = CurrTeam) or ((CurrTeam = TagTeamIndex) and ((GameFlags and gfTagTeam) <> 0)) 
8934
a4ec39eac0be
So. This should fix ammo delays being off on a team that is resurrected later in the game, even up freezing delays a bit, prevent an infinite loop in freezing, and reduces fuel burn when adjusting freezer to onefourth.
nemo
parents:
8681
diff
changeset

231 
end; 
a4ec39eac0be
So. This should fix ammo delays being off on a team that is resurrected later in the game, even up freezing delays a bit, prevent an infinite loop in freezing, and reduces fuel burn when adjusting freezer to onefourth.
nemo
parents:
8681
diff
changeset

232 
if (CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog].Gear = nil) or (CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog].Effects[heFrozen] > 255) then 
a4ec39eac0be
So. This should fix ammo delays being off on a team that is resurrected later in the game, even up freezing delays a bit, prevent an infinite loop in freezing, and reduces fuel burn when adjusting freezer to onefourth.
nemo
parents:
8681
diff
changeset

233 
begin 
a4ec39eac0be
So. This should fix ammo delays being off on a team that is resurrected later in the game, even up freezing delays a bit, prevent an infinite loop in freezing, and reduces fuel burn when adjusting freezer to onefourth.
nemo
parents:
8681
diff
changeset

234 
with CurrentTeam^.Clan^ do 
a4ec39eac0be
So. This should fix ammo delays being off on a team that is resurrected later in the game, even up freezing delays a bit, prevent an infinite loop in freezing, and reduces fuel burn when adjusting freezer to onefourth.
nemo
parents:
8681
diff
changeset

235 
for t:= 0 to Pred(TeamsNumber) do 
a4ec39eac0be
So. This should fix ammo delays being off on a team that is resurrected later in the game, even up freezing delays a bit, prevent an infinite loop in freezing, and reduces fuel burn when adjusting freezer to onefourth.
nemo
parents:
8681
diff
changeset

236 
with Teams[t]^ do 
a4ec39eac0be
So. This should fix ammo delays being off on a team that is resurrected later in the game, even up freezing delays a bit, prevent an infinite loop in freezing, and reduces fuel burn when adjusting freezer to onefourth.
nemo
parents:
8681
diff
changeset

237 
for i:= 0 to Pred(HedgehogsNumber) do 
a4ec39eac0be
So. This should fix ammo delays being off on a team that is resurrected later in the game, even up freezing delays a bit, prevent an infinite loop in freezing, and reduces fuel burn when adjusting freezer to onefourth.
nemo
parents:
8681
diff
changeset

238 
with Hedgehogs[i] do 
9157
2f8b60b89121
ok. this could be tidier, but, I'm sick of hogs w/ unmodified thaw thawing on exactly wrong turn.
nemo
parents:
9137
diff
changeset

239 
begin 
2f8b60b89121
ok. this could be tidier, but, I'm sick of hogs w/ unmodified thaw thawing on exactly wrong turn.
nemo
parents:
9137
diff
changeset

240 
if Effects[heFrozen] > 255 then Effects[heFrozen]:= max(255,Effects[heFrozen]50000); 
2f8b60b89121
ok. this could be tidier, but, I'm sick of hogs w/ unmodified thaw thawing on exactly wrong turn.
nemo
parents:
9137
diff
changeset

241 
if (Gear <> nil) and (Effects[heFrozen] < 256) and (CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog].Effects[heFrozen] > 255) then 
2f8b60b89121
ok. this could be tidier, but, I'm sick of hogs w/ unmodified thaw thawing on exactly wrong turn.
nemo
parents:
9137
diff
changeset

242 
CurrHedgehog:= i 
2f8b60b89121
ok. this could be tidier, but, I'm sick of hogs w/ unmodified thaw thawing on exactly wrong turn.
nemo
parents:
9137
diff
changeset

243 
end; 
2f8b60b89121
ok. this could be tidier, but, I'm sick of hogs w/ unmodified thaw thawing on exactly wrong turn.
nemo
parents:
9137
diff
changeset

244 
if (CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog].Gear = nil) or (CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog].Effects[heFrozen] > 255) then 
2f8b60b89121
ok. this could be tidier, but, I'm sick of hogs w/ unmodified thaw thawing on exactly wrong turn.
nemo
parents:
9137
diff
changeset

245 
inc(CurrentTeam^.Clan^.TurnNumber); 
8935  246 
end 
8934
a4ec39eac0be
So. This should fix ammo delays being off on a team that is resurrected later in the game, even up freezing delays a bit, prevent an infinite loop in freezing, and reduces fuel burn when adjusting freezer to onefourth.
nemo
parents:
8681
diff
changeset

247 
until (CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog].Gear <> nil) and (CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog].Effects[heFrozen] < 256); 
83  248 

7270
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset

249 
SwitchCurrentHedgehog(@(CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog])); 
6691
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6622
diff
changeset

250 
{$IFDEF USE_TOUCH_INTERFACE} 
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6622
diff
changeset

251 
if (Ammoz[CurrentHedgehog^.CurAmmoType].Ammo.Propz and ammoprop_NoCrosshair) = 0 then 
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6622
diff
changeset

252 
begin 
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6622
diff
changeset

253 
if not(arrowUp.show) then 
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6622
diff
changeset

254 
begin 
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6622
diff
changeset

255 
animateWidget(@arrowUp, true, true); 
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6622
diff
changeset

256 
animateWidget(@arrowDown, true, true); 
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6622
diff
changeset

257 
end; 
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6622
diff
changeset

258 
end 
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6622
diff
changeset

259 
else 
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6622
diff
changeset

260 
if arrowUp.show then 
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6622
diff
changeset

261 
begin 
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6622
diff
changeset

262 
animateWidget(@arrowUp, true, false); 
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6622
diff
changeset

263 
animateWidget(@arrowDown, true, false); 
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6622
diff
changeset

264 
end; 
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6622
diff
changeset

265 
{$ENDIF} 
6622  266 
AmmoMenuInvalidated:= true; 
1058
c53c5c4e7b48
 Proper turns counting, split SwitchHedgehog into two functions
unc0rr
parents:
1011
diff
changeset

267 
end; 
c53c5c4e7b48
 Proper turns counting, split SwitchHedgehog into two functions
unc0rr
parents:
1011
diff
changeset

268 

c53c5c4e7b48
 Proper turns counting, split SwitchHedgehog into two functions
unc0rr
parents:
1011
diff
changeset

269 
procedure AfterSwitchHedgehog; 
5357
ec36f3d53f3c
Tiny optimization: convert smooth wind indicator change gear into visual gear
unc0rr
parents:
5167
diff
changeset

270 
var i, t: LongInt; 
3960
ada50f8d4186
Remove bit of debug code from prior, don't switch weapons on end of turn (stick with whatever the last weapon was)
nemo
parents:
3935
diff
changeset

271 
CurWeapon: PAmmo; 
6913  272 
w: real; 
273 
vg: PVisualGear; 

13272
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset

274 
g: PGear; 
10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10116
diff
changeset

275 
s: ansistring; 
1058
c53c5c4e7b48
 Proper turns counting, split SwitchHedgehog into two functions
unc0rr
parents:
1011
diff
changeset

276 
begin 
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2758
diff
changeset

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

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

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

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

281 
for i:= 0 to cMaxHHIndex do 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

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

283 
PlacingHogs:= true; 
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2758
diff
changeset

284 

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

285 
if not PlacingHogs then // Reset various things I mucked with 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

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

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

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

289 
ClansArray[i]^.TurnNumber:= 0; 
13452
2d787d122083
Fix TotalRounds still being 1 in first real turn after hog placement phase
Wuzzy <Wuzzy2@mail.ru>
parents:
13412
diff
changeset

290 
ResetWeapons; 
2d787d122083
Fix TotalRounds still being 1 in first real turn after hog placement phase
Wuzzy <Wuzzy2@mail.ru>
parents:
13412
diff
changeset

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

292 
end 
13476
c265a3e6f6da
Make sure TotalRounds increases to 0 on first real turn
Wuzzy <Wuzzy2@mail.ru>
parents:
13452
diff
changeset

293 
end 
c265a3e6f6da
Make sure TotalRounds increases to 0 on first real turn
Wuzzy <Wuzzy2@mail.ru>
parents:
13452
diff
changeset

294 
else 
c265a3e6f6da
Make sure TotalRounds increases to 0 on first real turn
Wuzzy <Wuzzy2@mail.ru>
parents:
13452
diff
changeset

295 
if TotalRounds <= 1 then 
c265a3e6f6da
Make sure TotalRounds increases to 0 on first real turn
Wuzzy <Wuzzy2@mail.ru>
parents:
13452
diff
changeset

296 
TotalRounds:= 0; 
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2758
diff
changeset

297 

2431
23242609c44b
Real fix to ammo slot overflow (bug triggered by r2411 fix)
unc0rr
parents:
2376
diff
changeset

298 
inc(CurrentTeam^.Clan^.TurnNumber); 
8935  299 
with CurrentTeam^.Clan^ do 
300 
for t:= 0 to Pred(TeamsNumber) do 

301 
with Teams[t]^ do 

302 
for i:= 0 to Pred(HedgehogsNumber) do 

303 
with Hedgehogs[i] do 

304 
if Effects[heFrozen] > 255 then 

305 
Effects[heFrozen]:= max(255,Effects[heFrozen]50000); 

2431
23242609c44b
Real fix to ammo slot overflow (bug triggered by r2411 fix)
unc0rr
parents:
2376
diff
changeset

306 

6924  307 
CurWeapon:= GetCurAmmoEntry(CurrentHedgehog^); 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

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

309 
CurrentHedgehog^.CurAmmoType:= amNothing; 
2431
23242609c44b
Real fix to ammo slot overflow (bug triggered by r2411 fix)
unc0rr
parents:
2376
diff
changeset

310 

602  311 
with CurrentHedgehog^ do 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2905
diff
changeset

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

313 
with Gear^ do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2905
diff
changeset

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

315 
Z:= cCurrHHZ; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2905
diff
changeset

316 
State:= gstHHDriven; 
5063  317 
Active:= true; 
7835
a84936d1618a
Clear hedgehog's gear Power value when switching. Should fix issue 446 (not tested, but looks obvious).
unc0rr
parents:
7755
diff
changeset

318 
Power:= 0; 
5063  319 
LastDamage:= nil 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2905
diff
changeset

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

321 
RemoveGearFromList(Gear); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2905
diff
changeset

322 
InsertGearToList(Gear); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2905
diff
changeset

323 
FollowGear:= Gear 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2905
diff
changeset

324 
end; 
941
b5222ddafe1f
 Fix bug with picking up ammos from cases, when total ammo count may become more than AMMO_INFINITE
unc0rr
parents:
927
diff
changeset

325 

4218  326 
if (GameFlags and gfDisableWind) = 0 then 
327 
begin 

7001  328 
cWindSpeed:= rndSign(GetRandomf * 2 * cMaxWindSpeed); 
6913  329 
w:= hwFloat2Float(cWindSpeed); 
330 
vg:= AddVisualGear(0, 0, vgtSmoothWindBar); 

331 
if vg <> nil then vg^.dAngle:= w; 

4900  332 
AddFileLog('Wind = '+FloatToStr(cWindSpeed)); 
4218  333 
end; 
334 

602  335 
ApplyAmmoChanges(CurrentHedgehog^); 
800  336 

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

337 
if (not CurrentTeam^.ExtDriven) and (CurrentHedgehog^.BotLevel = 0) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

338 
SetBinds(CurrentTeam^.Binds); 
1650
a65681cc27c2
Don't fallback to default binds set when switching to remotely driven team
unc0rr
parents:
1495
diff
changeset

339 

2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2758
diff
changeset

340 
if PlacingHogs then 
5016
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset

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

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

343 
TurnTimeLeft:= 15000 
5016
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset

344 
else TurnTimeLeft:= 0 
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset

345 
end 
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset

346 
else 
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset

347 
begin 
13272
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset

348 
if ((GameFlags and gfTagTeam) <> 0) and (not NextClan) then 
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset

349 
begin 
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset

350 
if TagTurnTimeLeft <> 0 then 
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset

351 
TurnTimeLeft:= TagTurnTimeLeft; 
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset

352 
TagTurnTimeLeft:= 0; 
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset

353 
end 
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset

354 
else 
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset

355 
begin 
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset

356 
TurnTimeLeft:= cHedgehogTurnTime; 
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset

357 
TagTurnTimeLeft:= 0; 
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset

358 
NextClan:= false; 
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset

359 
end; 
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset

360 

5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset

361 
if (GameFlags and gfSwitchHog) <> 0 then 
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset

362 
begin 
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset

363 
g:= AddGear(hwRound(CurrentHedgehog^.Gear^.X), hwRound(CurrentHedgehog^.Gear^.Y), gtSwitcher, 0, _0, _0, 0); 
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset

364 
CurAmmoGear:= g; 
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset

365 
lastGearByUID:= g; 
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset

366 
end 
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset

367 
else 
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset

368 
bShowFinger:= true; 
5016
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset

369 
end; 
11913
232b57a70aca
Make the timer red when it is the getaway time
Wuzzy <almikes@aol.com>
parents:
11734
diff
changeset

370 
IsGetAwayTime:= false; 
7980
7f8df51553a7
Remove duplicate files from voices (add a fallback check in uSound). Add JustYouWait as an alternate to IllGetYou. Note that IllGetYou being called every turn seems awkward. IMO they probably should be reserved for significant enemy action. Maybe played by team of heavily damaged or killed hog.
nemo
parents:
7837
diff
changeset

371 

3774  372 
if (TurnTimeLeft > 0) and (CurrentHedgehog^.BotLevel = 0) then 
373 
begin 

12276
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset

374 
if CurrentTeam^.ExtDriven then 
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset

375 
begin 
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset

376 
if GetRandom(2) = 0 then 
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset

377 
AddVoice(sndIllGetYou, CurrentTeam^.voicepack) 
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset

378 
else AddVoice(sndJustYouWait, CurrentTeam^.voicepack) 
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset

379 
end 
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset

380 
else 
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset

381 
begin 
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset

382 
GetRandom(2); // needed to avoid extdriven desync 
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset

383 
AddVoice(sndYesSir, CurrentTeam^.voicepack); 
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset

384 
end; 
6905  385 
if cHedgehogTurnTime < 1000000 then 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

386 
ReadyTimeLeft:= cReadyDelay; 
10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10116
diff
changeset

387 
s:= ansistring(CurrentTeam^.TeamName); 
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10116
diff
changeset

388 
AddCaption(FormatA(trmsg[sidReady], s), cWhiteColor, capgrpGameState) 
3774  389 
end 
390 
else 

3798  391 
begin 
392 
if TurnTimeLeft > 0 then 

12276
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset

393 
begin 
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset

394 
if GetRandom(2) = 0 then 
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset

395 
AddVoice(sndIllGetYou, CurrentTeam^.voicepack) 
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset

396 
else AddVoice(sndJustYouWait, CurrentTeam^.voicepack) 
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset

397 
end; 
3798  398 
ReadyTimeLeft:= 0 
3952
d6412423da45
moved some utilities to a separate column with round buttons
koda
parents:
3935
diff
changeset

399 
end; 
4  400 
end; 
401 

549  402 
function AddTeam(TeamColor: Longword): PTeam; 
2695  403 
var team: PTeam; 
13068  404 
c: LongInt; 
4  405 
begin 
11532  406 
if checkFails(TeamsCount < cMaxTeams, 'Too many teams', true) then exit(nil); 
2695  407 
New(team); 
11532  408 
if checkFails(team <> nil, 'AddTeam: team = nil', true) then exit(nil); 
2695  409 
FillChar(team^, sizeof(TTeam), 0); 
410 
team^.AttackBar:= 2; 

2806  411 
team^.CurrHedgehog:= 0; 
2747  412 
team^.Flag:= 'hedgewars'; 
547  413 

2695  414 
TeamsArray[TeamsCount]:= team; 
547  415 
inc(TeamsCount); 
13174
061d55939e47
Use visible team count instead of total team count to determine rendered team bar height
Wuzzy <Wuzzy2@mail.ru>
parents:
13156
diff
changeset

416 
inc(VisibleTeamsCount); 
547  417 

13068  418 
team^.Binds:= DefaultBinds; 
8346  419 

549  420 
c:= Pred(ClansCount); 
421 
while (c >= 0) and (ClansArray[c]^.Color <> TeamColor) do dec(c); 

422 
if c < 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

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

424 
new(team^.Clan); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

425 
FillChar(team^.Clan^, sizeof(TClan), 0); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

426 
ClansArray[ClansCount]:= team^.Clan; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

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

428 
with team^.Clan^ do 
549  429 
begin 
550  430 
ClanIndex:= Pred(ClansCount); 
3379  431 
Color:= TeamColor; 
5016
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset

432 
TagTeamIndex:= 0; 
4978  433 
Flawless:= true 
549  434 
end 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

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

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

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

438 
team^.Clan:= ClansArray[c]; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

439 
end; 
549  440 

2695  441 
with team^.Clan^ do 
549  442 
begin 
2695  443 
Teams[TeamsNumber]:= team; 
549  444 
inc(TeamsNumber) 
445 
end; 

446 

11734  447 
// mirror changes into array for clans to spawn 
448 
SpawnClansArray:= ClansArray; 

449 

2695  450 
CurrentTeam:= team; 
451 
AddTeam:= team; 

4  452 
end; 
453 

47  454 
procedure RecountAllTeamsHealth; 
547  455 
var t: LongInt; 
2376  456 
begin 
547  457 
for t:= 0 to Pred(TeamsCount) do 
458 
RecountTeamHealth(TeamsArray[t]) 

47  459 
end; 
460 

461 
procedure InitTeams; 

547  462 
var i, t: LongInt; 
2784  463 
th, h: LongInt; 
47  464 
begin 
2726  465 

547  466 
for t:= 0 to Pred(TeamsCount) do 
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

467 
with TeamsArray[t]^ 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

468 
begin 
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

469 
if (not ExtDriven) and (Hedgehogs[0].BotLevel = 0) then 
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

470 
begin 
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

471 
LocalClan:= Clan^.ClanIndex; 
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:
4413
diff
changeset

472 
LocalTeam:= t; 
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

473 
LocalAmmo:= Hedgehogs[0].AmmoStore 
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

474 
end; 
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

475 
th:= 0; 
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

476 
for i:= 0 to cMaxHHIndex 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

477 
if Hedgehogs[i].Gear <> nil then 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

478 
inc(th, Hedgehogs[i].Gear^.Health); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

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

480 
MaxTeamHealth:= th; 
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

481 
// Some initial King buffs 
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

482 
if (GameFlags and gfKing) <> 0 then 
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

483 
begin 
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

484 
Hedgehogs[0].King:= true; 
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

485 
Hedgehogs[0].Hat:= 'crown'; 
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:
7001
diff
changeset

486 
Hedgehogs[0].Effects[hePoisoned] := 0; 
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

487 
h:= Hedgehogs[0].Gear^.Health; 
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

488 
Hedgehogs[0].Gear^.Health:= hwRound(int2hwFloat(th)*_0_375); 
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

489 
if Hedgehogs[0].Gear^.Health > h then 
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

490 
begin 
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

491 
dec(th, h); 
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

492 
inc(th, Hedgehogs[0].Gear^.Health); 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

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

494 
MaxTeamHealth:= th 
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

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

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

497 
Hedgehogs[0].Gear^.Health:= h; 
4102
96efb3bbf8e3
Extend shoppa hack to disable health crates to saucer and portal modes as well
nemo
parents:
4101
diff
changeset

498 
Hedgehogs[0].InitialHealth:= Hedgehogs[0].Gear^.Health 
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

499 
end; 
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

500 
end; 
2726  501 

47  502 
RecountAllTeamsHealth 
4  503 
end; 
504 

505 
function TeamSize(p: PTeam): Longword; 

2695  506 
var i, value: Longword; 
4  507 
begin 
2695  508 
value:= 0; 
4  509 
for i:= 0 to cMaxHHIndex do 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

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

511 
inc(value); 
2695  512 
TeamSize:= value; 
4  513 
end; 
514 

549  515 
procedure RecountClanHealth(clan: PClan); 
516 
var i: LongInt; 

517 
begin 

518 
with clan^ do 

519 
begin 

520 
ClanHealth:= 0; 

521 
for i:= 0 to Pred(TeamsNumber) do 

522 
inc(ClanHealth, Teams[i]^.TeamHealth) 

523 
end 

524 
end; 

525 

47  526 
procedure RecountTeamHealth(team: PTeam); 
371  527 
var i: LongInt; 
47  528 
begin 
529 
with team^ do 

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

530 
begin 
7990  531 
TeamHealth:= 0; 
532 
for i:= 0 to cMaxHHIndex do 

533 
if Hedgehogs[i].Gear <> nil then 

534 
inc(TeamHealth, Hedgehogs[i].Gear^.Health) 

535 
else if Hedgehogs[i].GearHidden <> nil then 

536 
inc(TeamHealth, Hedgehogs[i].GearHidden^.Health); 

2376  537 

9720
453a1c29b7e4
Animate hedgehogs healths inside team health bar. Proper animation for the case when max team health grows is lost though.
unc0rr
parents:
9685
diff
changeset

538 
if TeamHealth > MaxTeamHealth then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2905
diff
changeset

539 
begin 
9720
453a1c29b7e4
Animate hedgehogs healths inside team health bar. Proper animation for the case when max team health grows is lost though.
unc0rr
parents:
9685
diff
changeset

540 
MaxTeamHealth:= TeamHealth; 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2905
diff
changeset

541 
RecountAllTeamsHealth; 
9720
453a1c29b7e4
Animate hedgehogs healths inside team health bar. Proper animation for the case when max team health grows is lost though.
unc0rr
parents:
9685
diff
changeset

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

543 
end; 
549  544 

545 
RecountClanHealth(team^.Clan); 

546 

2005  547 
AddVisualGear(0, 0, vgtTeamHealthSorter) 
47  548 
end; 
549 

8817
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset

550 
procedure RestoreHog(HH: PHedgehog); 
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset

551 
begin 
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset

552 
HH^.Gear:=HH^.GearHidden; 
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset

553 
HH^.GearHidden:= nil; 
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset

554 
InsertGearToList(HH^.Gear); 
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset

555 
HH^.Gear^.State:= (HH^.Gear^.State and (not (gstHHDriven or gstInvisible or gstAttacking))) or gstAttacked; 
9291
15f7bb217b66
Make add/delete consistent (this has bugged me for so long)
nemo
parents:
9285
diff
changeset

556 
AddCI(HH^.Gear); 
8817
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset

557 
HH^.Gear^.Active:= true; 
13140
e330feceb662
Hide team bar if all hedgehogs in it are hidden or dead
Wuzzy <Wuzzy2@mail.ru>
parents:
13068
diff
changeset

558 
ScriptCall('onHogRestore', HH^.Gear^.Uid); 
e330feceb662
Hide team bar if all hedgehogs in it are hidden or dead
Wuzzy <Wuzzy2@mail.ru>
parents:
13068
diff
changeset

559 
AddVisualGear(0, 0, vgtTeamHealthSorter); 
8817
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset

560 
end; 
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset

561 

72  562 
procedure RestoreTeamsFromSave; 
547  563 
var t: LongInt; 
72  564 
begin 
547  565 
for t:= 0 to Pred(TeamsCount) do 
566 
TeamsArray[t]^.ExtDriven:= false 

72  567 
end; 
568 

2040  569 
procedure TeamGoneEffect(var Team: TTeam); 
570 
var i: LongInt; 

571 
begin 

10345  572 
with Team do 
573 
if skippedTurns < 3 then 

6131  574 
begin 
10349
a51de45dcc42
Fix some issues with rejoining (rejoining client still desyncs though)
unc0rr
parents:
10345
diff
changeset

575 
inc(skippedTurns); 
a51de45dcc42
Fix some issues with rejoining (rejoining client still desyncs though)
unc0rr
parents:
10345
diff
changeset

576 
for i:= 0 to cMaxHHIndex do 
a51de45dcc42
Fix some issues with rejoining (rejoining client still desyncs though)
unc0rr
parents:
10345
diff
changeset

577 
with Hedgehogs[i] do 
a51de45dcc42
Fix some issues with rejoining (rejoining client still desyncs though)
unc0rr
parents:
10345
diff
changeset

578 
if Gear <> nil then 
a51de45dcc42
Fix some issues with rejoining (rejoining client still desyncs though)
unc0rr
parents:
10345
diff
changeset

579 
Gear^.State:= Gear^.State and (not gstHHDriven); 
a51de45dcc42
Fix some issues with rejoining (rejoining client still desyncs though)
unc0rr
parents:
10345
diff
changeset

580 

a51de45dcc42
Fix some issues with rejoining (rejoining client still desyncs though)
unc0rr
parents:
10345
diff
changeset

581 
ParseCommand('/skip', true); 
10345  582 
end 
583 
else 

584 
for i:= 0 to cMaxHHIndex do 

585 
with Hedgehogs[i] do 

586 
begin 

587 
if Hedgehogs[i].GearHidden <> nil then 

588 
RestoreHog(@Hedgehogs[i]); 

6131  589 

10345  590 
if Gear <> nil then 
591 
begin 

592 
Gear^.Hedgehog^.Effects[heInvulnerable]:= 0; 

593 
Gear^.Damage:= Gear^.Health; 

594 
Gear^.State:= (Gear^.State or gstHHGone) and (not gstHHDriven) 

595 
end 

596 
end 

2040  597 
end; 
598 

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:
4393
diff
changeset

599 
procedure chAddHH(var id: 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:
4393
diff
changeset

600 
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:
4393
diff
changeset

601 
Gear: PGear; 
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:
4393
diff
changeset

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

603 
s:= ''; 
10883
294ef49efdd2
terminate engine and output fatal error message if hedgehogs are added incorrectly
sheepluva
parents:
10665
diff
changeset

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

605 
exit; 
11532  606 
if checkFails((CurrentTeam <> nil), 'Can''t add hedgehogs yet, add a team first!', true) then exit; 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

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

608 
begin 
11532  609 
if checkFails(HedgehogsNumber<=cMaxHHIndex, 'Can''t add hedgehog to "' + TeamName + '"! (already ' + intToStr(HedgehogsNumber) + ' hogs)', true) then exit; 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

610 
SplitBySpace(id, s); 
7270
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset

611 
SwitchCurrentHedgehog(@Hedgehogs[HedgehogsNumber]); 
8370  612 
CurrentHedgehog^.BotLevel:= StrToInt(id); 
9749
443d233316e5
make the team association with hog before calling gear creation. makes some lua a little easier
nemo
parents:
9720
diff
changeset

613 
CurrentHedgehog^.Team:= CurrentTeam; 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

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

615 
SplitBySpace(s, id); 
8370  616 
Gear^.Health:= StrToInt(s); 
11532  617 
if checkFails(Gear^.Health > 0, 'Invalid hedgehog health', true) then exit; 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

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

619 
CurrentHedgehog^.AmmoStore:= Clan^.ClanIndex 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

620 
else if (GameFlags and gfPerHogAmmo) <> 0 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:
4393
diff
changeset

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

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

623 
CurrentHedgehog^.AmmoStore:= StoreCnt  1 
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:
4393
diff
changeset

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

625 
else CurrentHedgehog^.AmmoStore:= TeamsCount  1; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

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

627 
CurrentHedgehog^.Name:= id; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

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

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

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

631 
end 
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4393
diff
changeset

632 
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:
4393
diff
changeset

633 

9407
860f959f92c9
Engine loads team binds from team config. Frontend still sends default binds commands, and default binds in team config aren't processed.
unc0rr
parents:
9295
diff
changeset

634 
procedure loadTeamBinds(s: shortstring); 
860f959f92c9
Engine loads team binds from team config. Frontend still sends default binds commands, and default binds in team config aren't processed.
unc0rr
parents:
9295
diff
changeset

635 
var i: LongInt; 
860f959f92c9
Engine loads team binds from team config. Frontend still sends default binds commands, and default binds in team config aren't processed.
unc0rr
parents:
9295
diff
changeset

636 
begin 
860f959f92c9
Engine loads team binds from team config. Frontend still sends default binds commands, and default binds in team config aren't processed.
unc0rr
parents:
9295
diff
changeset

637 
for i:= 1 to length(s) do 
9521
8054d9d775fd
merge with latest defaul, fixing compiling with fpc, parsing and rendering with pas2c, some minor problems with compiling with clang
koda
diff
changeset

638 
if ((s[i] = '\') or 
8054d9d775fd
merge with latest defaul, fixing compiling with fpc, parsing and rendering with pas2c, some minor problems with compiling with clang
koda
diff
changeset

639 
(s[i] = '/') or 
8054d9d775fd
merge with latest defaul, fixing compiling with fpc, parsing and rendering with pas2c, some minor problems with compiling with clang
koda
diff
changeset

640 
(s[i] = ':')) then 
8054d9d775fd
merge with latest defaul, fixing compiling with fpc, parsing and rendering with pas2c, some minor problems with compiling with clang
koda
diff
changeset

641 
s[i]:= '_'; 
9407
860f959f92c9
Engine loads team binds from team config. Frontend still sends default binds commands, and default binds in team config aren't processed.
unc0rr
parents:
9295
diff
changeset

642 

9466  643 
s:= cPathz[ptTeams] + '/' + s + '.hwt'; 
9464
901e363d5837
Finish rework of default binds system. Default binds now work even before first turn.
unc0rr
parents:
9407
diff
changeset

644 

9466  645 
loadBinds('bind', s); 
9407
860f959f92c9
Engine loads team binds from team config. Frontend still sends default binds commands, and default binds in team config aren't processed.
unc0rr
parents:
9295
diff
changeset

646 
end; 
860f959f92c9
Engine loads team binds from team config. Frontend still sends default binds commands, and default binds in team config aren't processed.
unc0rr
parents:
9295
diff
changeset

647 

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:
4393
diff
changeset

648 
procedure chAddTeam(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:
4393
diff
changeset

649 
var Color: Longword; 
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:
4393
diff
changeset

650 
ts, cs: 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:
4393
diff
changeset

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

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

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

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

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

656 
SplitBySpace(s, cs); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

657 
SplitBySpace(cs, ts); 
8370  658 
Color:= StrToInt(cs); 
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:
4393
diff
changeset

659 

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

660 
// color is always little endian so the mask must be constant also in big endian archs 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

661 
Color:= Color or $FF000000; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

662 
AddTeam(Color); 
11539  663 

664 
if CurrentTeam <> nil then 

665 
begin 

666 
CurrentTeam^.TeamName:= ts; 

667 
CurrentTeam^.PlayerHash:= s; 

668 
loadTeamBinds(ts); 

10015  669 

11539  670 
if GameType in [gmtDemo, gmtSave, gmtRecord] then 
671 
CurrentTeam^.ExtDriven:= 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:
4393
diff
changeset

672 

11539  673 
CurrentTeam^.voicepack:= AskForVoicepack('Default') 
674 
end 

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

675 
end 
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4393
diff
changeset

676 
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:
4393
diff
changeset

677 

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:
4393
diff
changeset

678 
procedure chSetHHCoords(var x: 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:
4393
diff
changeset

679 
var y: shortstring; 
8370  680 
t: 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:
4393
diff
changeset

681 
begin 
8370  682 
y:= ''; 
683 
if (not isDeveloperMode) or (CurrentHedgehog = nil) or (CurrentHedgehog^.Gear = nil) then 

684 
exit; 

685 
SplitBySpace(x, y); 

686 
t:= StrToInt(x); 

687 
CurrentHedgehog^.Gear^.X:= int2hwFloat(t); 

688 
t:= StrToInt(y); 

689 
CurrentHedgehog^.Gear^.Y:= int2hwFloat(t) 

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:
4393
diff
changeset

690 
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:
4393
diff
changeset

691 

4401  692 
procedure chBind(var id: shortstring); 
693 
begin 

9466  694 
if CurrentTeam = nil then 
695 
exit; 

7191
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset

696 

9466  697 
addBind(CurrentTeam^.Binds, id) 
4401  698 
end; 
699 

4404  700 
procedure chTeamGone(var s:shortstring); 
10344
cceabf9628bb
Fix issues with unsynced F and G messages being lost if current team which is supposed to convert them to synced f/g quits
unc0rr
parents:
10343
diff
changeset

701 
var t, i: LongInt; 
10343
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

702 
isSynced: boolean; 
4404  703 
begin 
10343
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

704 
isSynced:= s[1] = 's'; 
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

705 

fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

706 
Delete(s, 1, 1); 
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

707 

fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

708 
t:= 0; 
10665  709 
while (t < TeamsCount) and (TeamsArray[t]^.TeamName <> s) do 
10343
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

710 
inc(t); 
10665  711 
if t = TeamsCount then 
10343
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

712 
exit; 
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

713 

10397  714 
TeamsArray[t]^.isGoneFlagPendingToBeSet:= true; 
10344
cceabf9628bb
Fix issues with unsynced F and G messages being lost if current team which is supposed to convert them to synced f/g quits
unc0rr
parents:
10343
diff
changeset

715 

10343
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

716 
if isSynced then 
10665  717 
begin 
718 
for i:= 0 to Pred(TeamsCount) do 

719 
with TeamsArray[i]^ do 

10343
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

720 
begin 
10665  721 
if (not hasGone) and isGoneFlagPendingToBeSet then 
722 
begin 

13156
26f0c3669b4e
Make a few more engine strings translatable
Wuzzy <Wuzzy2@mail.ru>
parents:
13140
diff
changeset

723 
AddChatString(#7 + '* '+ FormatA(trmsg[sidTeamGone], TeamName)); 
10665  724 
if not CurrentTeam^.ExtDriven then SendIPC(_S'f' + s); 
725 
hasGone:= true; 

726 
skippedTurns:= 0; 

727 
isGoneFlagPendingToBeSet:= false; 

728 
RecountTeamHealth(TeamsArray[i]) 

729 
end; 

730 
if hasGone and isGoneFlagPendingToBeUnset then 

731 
ParseCommand('/teamback s' + s, true) 

732 
end 

733 
end 

10343
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

734 
else 
10665  735 
begin 
10944
c4b3440eeac6
 Fix order of messages, also don't duplicate last timestamped message
unc0rr
parents:
10883
diff
changeset

736 
//TeamsArray[t]^.isGoneFlagPendingToBeSet:= true; 
10344
cceabf9628bb
Fix issues with unsynced F and G messages being lost if current team which is supposed to convert them to synced f/g quits
unc0rr
parents:
10343
diff
changeset

737 

10398  738 
if (not CurrentTeam^.ExtDriven) or (CurrentTeam^.TeamName = s) or (CurrentTeam^.hasGone) then 
10665  739 
ParseCommand('/teamgone s' + s, true) 
740 
end; 

10343
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

741 
end; 
4404  742 

10343
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

743 
procedure chTeamBack(var s:shortstring); 
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

744 
var t: LongInt; 
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

745 
isSynced: boolean; 
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

746 
begin 
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

747 
isSynced:= s[1] = 's'; 
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

748 

fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

749 
Delete(s, 1, 1); 
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

750 

fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

751 
t:= 0; 
10665  752 
while (t < TeamsCount) and (TeamsArray[t]^.TeamName <> s) do 
10343
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

753 
inc(t); 
10665  754 
if t = TeamsCount then 
10343
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

755 
exit; 
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

756 

fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

757 
if isSynced then 
7119  758 
begin 
10343
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

759 
with TeamsArray[t]^ do 
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

760 
if hasGone then 
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

761 
begin 
13156
26f0c3669b4e
Make a few more engine strings translatable
Wuzzy <Wuzzy2@mail.ru>
parents:
13140
diff
changeset

762 
AddChatString(#8 + '* '+ FormatA(trmsg[sidTeamBack], TeamName)); 
10344
cceabf9628bb
Fix issues with unsynced F and G messages being lost if current team which is supposed to convert them to synced f/g quits
unc0rr
parents:
10343
diff
changeset

763 
if not CurrentTeam^.ExtDriven then SendIPC(_S'g' + s); 
10343
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

764 
hasGone:= false; 
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

765 

fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

766 
RecountTeamHealth(TeamsArray[t]); 
4404  767 

10397  768 
if isGoneFlagPendingToBeUnset and (Owner = UserNick) then 
10350
4e919f7b9d92
Don't pick up own team if only recieved synced teamback message. Fixes second rejoin desync (untested).
unc0rr
parents:
10349
diff
changeset

769 
ExtDriven:= false; 
4e919f7b9d92
Don't pick up own team if only recieved synced teamback message. Fixes second rejoin desync (untested).
unc0rr
parents:
10349
diff
changeset

770 

10397  771 
isGoneFlagPendingToBeUnset:= false; 
10343
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

772 
end; 
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

773 
end 
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

774 
else 
10665  775 
begin 
10397  776 
TeamsArray[t]^.isGoneFlagPendingToBeUnset:= true; 
10344
cceabf9628bb
Fix issues with unsynced F and G messages being lost if current team which is supposed to convert them to synced f/g quits
unc0rr
parents:
10343
diff
changeset

777 

10343
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

778 
if not CurrentTeam^.ExtDriven then 
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

779 
ParseCommand('/teamback s' + s, true); 
10665  780 
end; 
4404  781 
end; 
782 

783 

7270
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset

784 
procedure SwitchCurrentHedgehog(newHog: PHedgehog); 
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset

785 
var oldCI, newCI: boolean; 
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset

786 
oldHH: PHedgehog; 
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset

787 
begin 
7755
b8958e64e68d
Also shove using shotgun, switch off hat when not active hog
nemo
parents:
7669
diff
changeset

788 
if (CurrentHedgehog <> nil) and (CurrentHedgehog^.CurAmmoType = amKnife) then 
b8958e64e68d
Also shove using shotgun, switch off hat when not active hog
nemo
parents:
7669
diff
changeset

789 
LoadHedgehogHat(CurrentHedgehog^, CurrentHedgehog^.Hat); 
7270
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset

790 
oldCI:= (CurrentHedgehog <> nil) and (CurrentHedgehog^.Gear <> nil) and (CurrentHedgehog^.Gear^.CollisionIndex >= 0); 
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset

791 
newCI:= (newHog^.Gear <> nil) and (newHog^.Gear^.CollisionIndex >= 0); 
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset

792 
if oldCI then DeleteCI(CurrentHedgehog^.Gear); 
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset

793 
if newCI then DeleteCI(newHog^.Gear); 
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset

794 
oldHH:= CurrentHedgehog; 
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset

795 
CurrentHedgehog:= newHog; 
9291
15f7bb217b66
Make add/delete consistent (this has bugged me for so long)
nemo
parents:
9285
diff
changeset

796 
if oldCI then AddCI(oldHH^.Gear); 
15f7bb217b66
Make add/delete consistent (this has bugged me for so long)
nemo
parents:
9285
diff
changeset

797 
if newCI then AddCI(newHog^.Gear) 
7270
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset

798 
end; 
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset

799 

93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset

800 

9790  801 
procedure chSetHat(var s: shortstring); 
802 
begin 

803 
if (not isDeveloperMode) or (CurrentTeam = nil) then exit; 

804 
with CurrentTeam^ do 

805 
begin 

806 
if not CurrentHedgehog^.King then 

807 
if (s = '') 

808 
or (((GameFlags and gfKing) <> 0) and (s = 'crown')) 

809 
or ((Length(s) > 39) and (Copy(s,1,8) = 'Reserved') and (Copy(s,9,32) <> PlayerHash)) then 

810 
CurrentHedgehog^.Hat:= 'NoHat' 

811 
else 

812 
CurrentHedgehog^.Hat:= s 

813 
end; 

814 
end; 

815 

816 
procedure chGrave(var s: shortstring); 

817 
begin 

818 
if CurrentTeam = nil then 

819 
OutError(errmsgIncorrectUse + ' "/grave"', true); 

820 
if s[1]='"' then 

821 
Delete(s, 1, 1); 

822 
if s[byte(s[0])]='"' then 

823 
Delete(s, byte(s[0]), 1); 

824 
CurrentTeam^.GraveName:= s 

825 
end; 

826 

827 
procedure chFort(var s: shortstring); 

828 
begin 

829 
if CurrentTeam = nil then 

830 
OutError(errmsgIncorrectUse + ' "/fort"', true); 

831 
if s[1]='"' then 

832 
Delete(s, 1, 1); 

833 
if s[byte(s[0])]='"' then 

834 
Delete(s, byte(s[0]), 1); 

835 
CurrentTeam^.FortName:= s 

836 
end; 

837 

838 
procedure chFlag(var s: shortstring); 

839 
begin 

840 
if CurrentTeam = nil then 

841 
OutError(errmsgIncorrectUse + ' "/flag"', true); 

842 
if s[1]='"' then 

843 
Delete(s, 1, 1); 

844 
if s[byte(s[0])]='"' then 

845 
Delete(s, byte(s[0]), 1); 

846 
CurrentTeam^.flag:= s 

847 
end; 

848 

849 
procedure chOwner(var s: shortstring); 

850 
begin 

851 
if CurrentTeam = nil then 

852 
OutError(errmsgIncorrectUse + ' "/owner"', true); 

853 

854 
CurrentTeam^.Owner:= s 

855 
end; 

856 

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

858 
begin 
6898  859 
RegisterVariable('addhh', @chAddHH, false); 
860 
RegisterVariable('addteam', @chAddTeam, false); 

861 
RegisterVariable('hhcoords', @chSetHHCoords, false); 

862 
RegisterVariable('bind', @chBind, true ); 

863 
RegisterVariable('teamgone', @chTeamGone, true ); 

10343
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset

864 
RegisterVariable('teamback', @chTeamBack, true ); 
9790  865 
RegisterVariable('fort' , @chFort , false); 
866 
RegisterVariable('grave' , @chGrave , false); 

867 
RegisterVariable('hat' , @chSetHat , false); 

868 
RegisterVariable('flag' , @chFlag , false); 

869 
RegisterVariable('owner' , @chOwner , false); 

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:
4393
diff
changeset

870 

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

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

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

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

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

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

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

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

878 
LocalAmmo:= 1; 
13245
195208deff1d
 Correct initialisation of TeamsGameOver (on mobile it doesn't get reset between plays, so ones set to true, prevents game to be finished next time)
antonc27 <antonc27@mail.ru>
parents:
12579
diff
changeset

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

880 
NextClan:= true; 
6982  881 
MaxTeamHealth:= 0; 
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset

882 
end; 
4  883 

3038  884 
procedure freeModule; 
4881
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4514
diff
changeset

885 
var i, h: LongWord; 
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset

886 
begin 
10635
8e8b320eefad
nil out CurrentHedgehog in FreeModule, add a test for nil'd CurrentHedgehog in DelCI since I'd still like to use DeleteGear for the other stuff it does. Move some variable initialiasations in AI Misc to hopefully avoid some uninit val errors.
nemo
parents:
10634
diff
changeset

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

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

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

890 
for i:= 0 to Pred(TeamsCount) do 
4881
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4514
diff
changeset

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

892 
for h:= 0 to cMaxHHIndex do 
9468
3d07fd84c39d
 Actually call uTexture.initModule and .freeModule
unc0rr
parents:
9466
diff
changeset

893 
with TeamsArray[i]^.Hedgehogs[h] do 
3d07fd84c39d
 Actually call uTexture.initModule and .freeModule
unc0rr
parents:
9466
diff
changeset

894 
begin 
10646
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10643
diff
changeset

895 
// if Gear <> nil then 
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10643
diff
changeset

896 
// DeleteGearStage(Gear, true); 
9468
3d07fd84c39d
 Actually call uTexture.initModule and .freeModule
unc0rr
parents:
9466
diff
changeset

897 
if GearHidden <> nil then 
10646
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10643
diff
changeset

898 
Dispose(GearHidden); 
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10643
diff
changeset

899 
// DeleteGearStage(GearHidden, true); 
9655
e154ccca4dad
Tinted crosshair (without that cool white dot in the middle)
unc0rr
parents:
9468
diff
changeset

900 

10634
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10581
diff
changeset

901 
FreeAndNilTexture(NameTagTex); 
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10581
diff
changeset

902 
FreeAndNilTexture(HealthTagTex); 
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10581
diff
changeset

903 
FreeAndNilTexture(HatTex) 
9468
3d07fd84c39d
 Actually call uTexture.initModule and .freeModule
unc0rr
parents:
9466
diff
changeset

904 
end; 
9655
e154ccca4dad
Tinted crosshair (without that cool white dot in the middle)
unc0rr
parents:
9468
diff
changeset

905 

9468
3d07fd84c39d
 Actually call uTexture.initModule and .freeModule
unc0rr
parents:
9466
diff
changeset

906 
with TeamsArray[i]^ do 
3d07fd84c39d
 Actually call uTexture.initModule and .freeModule
unc0rr
parents:
9466
diff
changeset

907 
begin 
10634
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10581
diff
changeset

908 
FreeAndNilTexture(NameTagTex); 
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10581
diff
changeset

909 
FreeAndNilTexture(OwnerTex); 
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10581
diff
changeset

910 
FreeAndNilTexture(GraveTex); 
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10581
diff
changeset

911 
FreeAndNilTexture(AIKillsTex); 
13018
0248cf0da834
Add SetTeamLabel to Lua API, can set arbitrary string as team label
Wuzzy <Wuzzy2@mail.ru>
parents:
12919
diff
changeset

912 
FreeAndNilTexture(LuaTeamValueTex); 
10634
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10581
diff
changeset

913 
FreeAndNilTexture(FlagTex); 
9468
3d07fd84c39d
 Actually call uTexture.initModule and .freeModule
unc0rr
parents:
9466
diff
changeset

914 
end; 
9655
e154ccca4dad
Tinted crosshair (without that cool white dot in the middle)
unc0rr
parents:
9468
diff
changeset

915 

10634
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10581
diff
changeset

916 
Dispose(TeamsArray[i]) 
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10581
diff
changeset

917 
end; 
9656  918 
for i:= 0 to Pred(ClansCount) do 
919 
begin 

10634
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10581
diff
changeset

920 
FreeAndNilTexture(ClansArray[i]^.HealthTex); 
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10581
diff
changeset

921 
Dispose(ClansArray[i]) 
9656  922 
end 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset

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

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

925 
ClansCount:= 0; 
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset

926 
end; 
4  927 

928 
end. 