author | nemo |
Fri, 30 Mar 2018 11:56:16 -0400 | |
changeset 13304 | 5ac2bdefa173 |
parent 13272 | 5984e8c6cbeb |
child 13412 | 236cc4cf2448 |
permissions | -rw-r--r-- |
9285 | 1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
11046 | 3 |
* Copyright (c) 2004-2015 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 02110-1301 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 force-ending 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 pascal-ish 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 pascal-ish 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 pascal-ish 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 force-ending 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 per-team 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 force-ending 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 per-hog-ammo, 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 per-hog-ammo mode |
de9e1a5102b4
In the case of per-hog-ammo, 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 per-hog-ammo, 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 per-hog-ammo, 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 per-hog-ammo, 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 per-hog-ammo, 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 per-hog-ammo, 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 per-hog-ammo, 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 per-hog-ammo, 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 per-hog-ammo, 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 per-hog-ammo, 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 one-fourth.
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 one-fourth.
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 one-fourth.
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 one-fourth.
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 one-fourth.
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 one-fourth.
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 one-fourth.
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 one-fourth.
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 one-fourth.
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; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
290 |
ResetWeapons |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
291 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
292 |
end; |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2758
diff
changeset
|
293 |
|
2431
23242609c44b
Real fix to ammo slot overflow (bug triggered by r2411 fix)
unc0rr
parents:
2376
diff
changeset
|
294 |
inc(CurrentTeam^.Clan^.TurnNumber); |
8935 | 295 |
with CurrentTeam^.Clan^ do |
296 |
for t:= 0 to Pred(TeamsNumber) do |
|
297 |
with Teams[t]^ do |
|
298 |
for i:= 0 to Pred(HedgehogsNumber) do |
|
299 |
with Hedgehogs[i] do |
|
300 |
if Effects[heFrozen] > 255 then |
|
301 |
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
|
302 |
|
6924 | 303 |
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
|
304 |
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
|
305 |
CurrentHedgehog^.CurAmmoType:= amNothing; |
2431
23242609c44b
Real fix to ammo slot overflow (bug triggered by r2411 fix)
unc0rr
parents:
2376
diff
changeset
|
306 |
|
602 | 307 |
with CurrentHedgehog^ do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
308 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
309 |
with Gear^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
310 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
311 |
Z:= cCurrHHZ; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
312 |
State:= gstHHDriven; |
5063 | 313 |
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
|
314 |
Power:= 0; |
5063 | 315 |
LastDamage:= nil |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
316 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
317 |
RemoveGearFromList(Gear); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
318 |
InsertGearToList(Gear); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
319 |
FollowGear:= Gear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
320 |
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
|
321 |
|
4218 | 322 |
if (GameFlags and gfDisableWind) = 0 then |
323 |
begin |
|
7001 | 324 |
cWindSpeed:= rndSign(GetRandomf * 2 * cMaxWindSpeed); |
6913 | 325 |
w:= hwFloat2Float(cWindSpeed); |
326 |
vg:= AddVisualGear(0, 0, vgtSmoothWindBar); |
|
327 |
if vg <> nil then vg^.dAngle:= w; |
|
4900 | 328 |
AddFileLog('Wind = '+FloatToStr(cWindSpeed)); |
4218 | 329 |
end; |
330 |
||
602 | 331 |
ApplyAmmoChanges(CurrentHedgehog^); |
800 | 332 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
333 |
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
|
334 |
SetBinds(CurrentTeam^.Binds); |
1650
a65681cc27c2
Don't fallback to default binds set when switching to remotely driven team
unc0rr
parents:
1495
diff
changeset
|
335 |
|
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2758
diff
changeset
|
336 |
if PlacingHogs then |
5016
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset
|
337 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
338 |
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
|
339 |
TurnTimeLeft:= 15000 |
5016
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset
|
340 |
else TurnTimeLeft:= 0 |
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset
|
341 |
end |
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset
|
342 |
else |
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset
|
343 |
begin |
13272
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset
|
344 |
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
|
345 |
begin |
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset
|
346 |
if TagTurnTimeLeft <> 0 then |
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset
|
347 |
TurnTimeLeft:= TagTurnTimeLeft; |
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset
|
348 |
TagTurnTimeLeft:= 0; |
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset
|
349 |
end |
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset
|
350 |
else |
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset
|
351 |
begin |
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset
|
352 |
TurnTimeLeft:= cHedgehogTurnTime; |
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset
|
353 |
TagTurnTimeLeft:= 0; |
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset
|
354 |
NextClan:= false; |
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset
|
355 |
end; |
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset
|
356 |
|
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset
|
357 |
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
|
358 |
begin |
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset
|
359 |
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
|
360 |
CurAmmoGear:= g; |
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset
|
361 |
lastGearByUID:= g; |
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset
|
362 |
end |
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset
|
363 |
else |
5984e8c6cbeb
Add new game flag gfSwitchHog, enable hog switching at turn start
Wuzzy <Wuzzy2@mail.ru>
parents:
13174
diff
changeset
|
364 |
bShowFinger:= true; |
5016
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset
|
365 |
end; |
11913
232b57a70aca
Make the timer red when it is the get-away time
Wuzzy <almikes@aol.com>
parents:
11734
diff
changeset
|
366 |
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
|
367 |
|
3774 | 368 |
if (TurnTimeLeft > 0) and (CurrentHedgehog^.BotLevel = 0) then |
369 |
begin |
|
12276
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset
|
370 |
if CurrentTeam^.ExtDriven then |
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset
|
371 |
begin |
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset
|
372 |
if GetRandom(2) = 0 then |
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset
|
373 |
AddVoice(sndIllGetYou, CurrentTeam^.voicepack) |
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset
|
374 |
else AddVoice(sndJustYouWait, CurrentTeam^.voicepack) |
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset
|
375 |
end |
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset
|
376 |
else |
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset
|
377 |
begin |
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset
|
378 |
GetRandom(2); // needed to avoid extdriven desync |
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset
|
379 |
AddVoice(sndYesSir, CurrentTeam^.voicepack); |
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset
|
380 |
end; |
6905 | 381 |
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
|
382 |
ReadyTimeLeft:= cReadyDelay; |
10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10116
diff
changeset
|
383 |
s:= ansistring(CurrentTeam^.TeamName); |
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10116
diff
changeset
|
384 |
AddCaption(FormatA(trmsg[sidReady], s), cWhiteColor, capgrpGameState) |
3774 | 385 |
end |
386 |
else |
|
3798 | 387 |
begin |
388 |
if TurnTimeLeft > 0 then |
|
12276
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset
|
389 |
begin |
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset
|
390 |
if GetRandom(2) = 0 then |
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset
|
391 |
AddVoice(sndIllGetYou, CurrentTeam^.voicepack) |
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset
|
392 |
else AddVoice(sndJustYouWait, CurrentTeam^.voicepack) |
12f28d866c76
Backed out changeset 8e9603088f99
Wuzzy <almikes@aol.com>
parents:
12253
diff
changeset
|
393 |
end; |
3798 | 394 |
ReadyTimeLeft:= 0 |
3952
d6412423da45
moved some utilities to a separate column with round buttons
koda
parents:
3935
diff
changeset
|
395 |
end; |
4 | 396 |
end; |
397 |
||
549 | 398 |
function AddTeam(TeamColor: Longword): PTeam; |
2695 | 399 |
var team: PTeam; |
13068 | 400 |
c: LongInt; |
4 | 401 |
begin |
11532 | 402 |
if checkFails(TeamsCount < cMaxTeams, 'Too many teams', true) then exit(nil); |
2695 | 403 |
New(team); |
11532 | 404 |
if checkFails(team <> nil, 'AddTeam: team = nil', true) then exit(nil); |
2695 | 405 |
FillChar(team^, sizeof(TTeam), 0); |
406 |
team^.AttackBar:= 2; |
|
2806 | 407 |
team^.CurrHedgehog:= 0; |
2747 | 408 |
team^.Flag:= 'hedgewars'; |
547 | 409 |
|
2695 | 410 |
TeamsArray[TeamsCount]:= team; |
547 | 411 |
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
|
412 |
inc(VisibleTeamsCount); |
547 | 413 |
|
13068 | 414 |
team^.Binds:= DefaultBinds; |
8346 | 415 |
|
549 | 416 |
c:= Pred(ClansCount); |
417 |
while (c >= 0) and (ClansArray[c]^.Color <> TeamColor) do dec(c); |
|
418 |
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
|
419 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
420 |
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
|
421 |
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
|
422 |
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
|
423 |
inc(ClansCount); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
424 |
with team^.Clan^ do |
549 | 425 |
begin |
550 | 426 |
ClanIndex:= Pred(ClansCount); |
3379 | 427 |
Color:= TeamColor; |
5016
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset
|
428 |
TagTeamIndex:= 0; |
4978 | 429 |
Flawless:= true |
549 | 430 |
end |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
431 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
432 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
433 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
434 |
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
|
435 |
end; |
549 | 436 |
|
2695 | 437 |
with team^.Clan^ do |
549 | 438 |
begin |
2695 | 439 |
Teams[TeamsNumber]:= team; |
549 | 440 |
inc(TeamsNumber) |
441 |
end; |
|
442 |
||
11734 | 443 |
// mirror changes into array for clans to spawn |
444 |
SpawnClansArray:= ClansArray; |
|
445 |
||
2695 | 446 |
CurrentTeam:= team; |
447 |
AddTeam:= team; |
|
4 | 448 |
end; |
449 |
||
47 | 450 |
procedure RecountAllTeamsHealth; |
547 | 451 |
var t: LongInt; |
2376 | 452 |
begin |
547 | 453 |
for t:= 0 to Pred(TeamsCount) do |
454 |
RecountTeamHealth(TeamsArray[t]) |
|
47 | 455 |
end; |
456 |
||
457 |
procedure InitTeams; |
|
547 | 458 |
var i, t: LongInt; |
2784 | 459 |
th, h: LongInt; |
47 | 460 |
begin |
2726 | 461 |
|
547 | 462 |
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
|
463 |
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
|
464 |
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
|
465 |
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
|
466 |
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
|
467 |
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
|
468 |
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
|
469 |
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
|
470 |
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
|
471 |
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
|
472 |
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
|
473 |
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
|
474 |
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
|
475 |
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
|
476 |
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
|
477 |
// 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
|
478 |
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
|
479 |
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
|
480 |
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
|
481 |
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
|
482 |
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
|
483 |
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
|
484 |
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
|
485 |
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
|
486 |
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
|
487 |
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
|
488 |
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
|
489 |
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
|
490 |
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
|
491 |
end |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
492 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
493 |
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
|
494 |
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
|
495 |
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
|
496 |
end; |
2726 | 497 |
|
47 | 498 |
RecountAllTeamsHealth |
4 | 499 |
end; |
500 |
||
501 |
function TeamSize(p: PTeam): Longword; |
|
2695 | 502 |
var i, value: Longword; |
4 | 503 |
begin |
2695 | 504 |
value:= 0; |
4 | 505 |
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
|
506 |
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
|
507 |
inc(value); |
2695 | 508 |
TeamSize:= value; |
4 | 509 |
end; |
510 |
||
549 | 511 |
procedure RecountClanHealth(clan: PClan); |
512 |
var i: LongInt; |
|
513 |
begin |
|
514 |
with clan^ do |
|
515 |
begin |
|
516 |
ClanHealth:= 0; |
|
517 |
for i:= 0 to Pred(TeamsNumber) do |
|
518 |
inc(ClanHealth, Teams[i]^.TeamHealth) |
|
519 |
end |
|
520 |
end; |
|
521 |
||
47 | 522 |
procedure RecountTeamHealth(team: PTeam); |
371 | 523 |
var i: LongInt; |
47 | 524 |
begin |
525 |
with team^ do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
526 |
begin |
7990 | 527 |
TeamHealth:= 0; |
528 |
for i:= 0 to cMaxHHIndex do |
|
529 |
if Hedgehogs[i].Gear <> nil then |
|
530 |
inc(TeamHealth, Hedgehogs[i].Gear^.Health) |
|
531 |
else if Hedgehogs[i].GearHidden <> nil then |
|
532 |
inc(TeamHealth, Hedgehogs[i].GearHidden^.Health); |
|
2376 | 533 |
|
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
|
534 |
if TeamHealth > MaxTeamHealth then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
535 |
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
|
536 |
MaxTeamHealth:= TeamHealth; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
537 |
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
|
538 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
539 |
end; |
549 | 540 |
|
541 |
RecountClanHealth(team^.Clan); |
|
542 |
||
2005 | 543 |
AddVisualGear(0, 0, vgtTeamHealthSorter) |
47 | 544 |
end; |
545 |
||
8817
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset
|
546 |
procedure RestoreHog(HH: PHedgehog); |
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset
|
547 |
begin |
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset
|
548 |
HH^.Gear:=HH^.GearHidden; |
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset
|
549 |
HH^.GearHidden:= nil; |
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset
|
550 |
InsertGearToList(HH^.Gear); |
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset
|
551 |
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
|
552 |
AddCI(HH^.Gear); |
8817
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset
|
553 |
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
|
554 |
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
|
555 |
AddVisualGear(0, 0, vgtTeamHealthSorter); |
8817
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset
|
556 |
end; |
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset
|
557 |
|
72 | 558 |
procedure RestoreTeamsFromSave; |
547 | 559 |
var t: LongInt; |
72 | 560 |
begin |
547 | 561 |
for t:= 0 to Pred(TeamsCount) do |
562 |
TeamsArray[t]^.ExtDriven:= false |
|
72 | 563 |
end; |
564 |
||
2040 | 565 |
procedure TeamGoneEffect(var Team: TTeam); |
566 |
var i: LongInt; |
|
567 |
begin |
|
10345 | 568 |
with Team do |
569 |
if skippedTurns < 3 then |
|
6131 | 570 |
begin |
10349
a51de45dcc42
Fix some issues with rejoining (rejoining client still desyncs though)
unc0rr
parents:
10345
diff
changeset
|
571 |
inc(skippedTurns); |
a51de45dcc42
Fix some issues with rejoining (rejoining client still desyncs though)
unc0rr
parents:
10345
diff
changeset
|
572 |
for i:= 0 to cMaxHHIndex do |
a51de45dcc42
Fix some issues with rejoining (rejoining client still desyncs though)
unc0rr
parents:
10345
diff
changeset
|
573 |
with Hedgehogs[i] do |
a51de45dcc42
Fix some issues with rejoining (rejoining client still desyncs though)
unc0rr
parents:
10345
diff
changeset
|
574 |
if Gear <> nil then |
a51de45dcc42
Fix some issues with rejoining (rejoining client still desyncs though)
unc0rr
parents:
10345
diff
changeset
|
575 |
Gear^.State:= Gear^.State and (not gstHHDriven); |
a51de45dcc42
Fix some issues with rejoining (rejoining client still desyncs though)
unc0rr
parents:
10345
diff
changeset
|
576 |
|
a51de45dcc42
Fix some issues with rejoining (rejoining client still desyncs though)
unc0rr
parents:
10345
diff
changeset
|
577 |
ParseCommand('/skip', true); |
10345 | 578 |
end |
579 |
else |
|
580 |
for i:= 0 to cMaxHHIndex do |
|
581 |
with Hedgehogs[i] do |
|
582 |
begin |
|
583 |
if Hedgehogs[i].GearHidden <> nil then |
|
584 |
RestoreHog(@Hedgehogs[i]); |
|
6131 | 585 |
|
10345 | 586 |
if Gear <> nil then |
587 |
begin |
|
588 |
Gear^.Hedgehog^.Effects[heInvulnerable]:= 0; |
|
589 |
Gear^.Damage:= Gear^.Health; |
|
590 |
Gear^.State:= (Gear^.State or gstHHGone) and (not gstHHDriven) |
|
591 |
end |
|
592 |
end |
|
2040 | 593 |
end; |
594 |
||
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
|
595 |
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
|
596 |
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
|
597 |
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
|
598 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
599 |
s:= ''; |
10883
294ef49efdd2
terminate engine and output fatal error message if hedgehogs are added incorrectly
sheepluva
parents:
10665
diff
changeset
|
600 |
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
|
601 |
exit; |
11532 | 602 |
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
|
603 |
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
|
604 |
begin |
11532 | 605 |
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
|
606 |
SplitBySpace(id, s); |
7270
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset
|
607 |
SwitchCurrentHedgehog(@Hedgehogs[HedgehogsNumber]); |
8370 | 608 |
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
|
609 |
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
|
610 |
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
|
611 |
SplitBySpace(s, id); |
8370 | 612 |
Gear^.Health:= StrToInt(s); |
11532 | 613 |
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
|
614 |
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
|
615 |
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
|
616 |
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
|
617 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
618 |
AddAmmoStore; |
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:= 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
|
620 |
end |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
621 |
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
|
622 |
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
|
623 |
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
|
624 |
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
|
625 |
CurrHedgehog:= HedgehogsNumber; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
626 |
inc(HedgehogsNumber) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
627 |
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
|
628 |
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
|
629 |
|
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
|
630 |
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
|
631 |
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
|
632 |
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
|
633 |
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
|
634 |
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
|
635 |
(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
|
636 |
(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
|
637 |
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
|
638 |
|
9466 | 639 |
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
|
640 |
|
9466 | 641 |
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
|
642 |
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
|
643 |
|
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
|
644 |
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
|
645 |
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
|
646 |
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
|
647 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
648 |
cs:= ''; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
649 |
ts:= ''; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
650 |
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
|
651 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
652 |
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
|
653 |
SplitBySpace(cs, ts); |
8370 | 654 |
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
|
655 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
656 |
// 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
|
657 |
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
|
658 |
AddTeam(Color); |
11539 | 659 |
|
660 |
if CurrentTeam <> nil then |
|
661 |
begin |
|
662 |
CurrentTeam^.TeamName:= ts; |
|
663 |
CurrentTeam^.PlayerHash:= s; |
|
664 |
loadTeamBinds(ts); |
|
10015 | 665 |
|
11539 | 666 |
if GameType in [gmtDemo, gmtSave, gmtRecord] then |
667 |
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
|
668 |
|
11539 | 669 |
CurrentTeam^.voicepack:= AskForVoicepack('Default') |
670 |
end |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
671 |
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
|
672 |
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
|
673 |
|
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
|
674 |
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
|
675 |
var y: shortstring; |
8370 | 676 |
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
|
677 |
begin |
8370 | 678 |
y:= ''; |
679 |
if (not isDeveloperMode) or (CurrentHedgehog = nil) or (CurrentHedgehog^.Gear = nil) then |
|
680 |
exit; |
|
681 |
SplitBySpace(x, y); |
|
682 |
t:= StrToInt(x); |
|
683 |
CurrentHedgehog^.Gear^.X:= int2hwFloat(t); |
|
684 |
t:= StrToInt(y); |
|
685 |
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
|
686 |
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
|
687 |
|
4401 | 688 |
procedure chBind(var id: shortstring); |
689 |
begin |
|
9466 | 690 |
if CurrentTeam = nil then |
691 |
exit; |
|
7191
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
692 |
|
9466 | 693 |
addBind(CurrentTeam^.Binds, id) |
4401 | 694 |
end; |
695 |
||
4404 | 696 |
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
|
697 |
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
|
698 |
isSynced: boolean; |
4404 | 699 |
begin |
10343
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset
|
700 |
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
|
701 |
|
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset
|
702 |
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
|
703 |
|
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset
|
704 |
t:= 0; |
10665 | 705 |
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
|
706 |
inc(t); |
10665 | 707 |
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
|
708 |
exit; |
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset
|
709 |
|
10397 | 710 |
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
|
711 |
|
10343
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset
|
712 |
if isSynced then |
10665 | 713 |
begin |
714 |
for i:= 0 to Pred(TeamsCount) do |
|
715 |
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
|
716 |
begin |
10665 | 717 |
if (not hasGone) and isGoneFlagPendingToBeSet then |
718 |
begin |
|
13156
26f0c3669b4e
Make a few more engine strings translatable
Wuzzy <Wuzzy2@mail.ru>
parents:
13140
diff
changeset
|
719 |
AddChatString(#7 + '* '+ FormatA(trmsg[sidTeamGone], TeamName)); |
10665 | 720 |
if not CurrentTeam^.ExtDriven then SendIPC(_S'f' + s); |
721 |
hasGone:= true; |
|
722 |
skippedTurns:= 0; |
|
723 |
isGoneFlagPendingToBeSet:= false; |
|
724 |
RecountTeamHealth(TeamsArray[i]) |
|
725 |
end; |
|
726 |
if hasGone and isGoneFlagPendingToBeUnset then |
|
727 |
ParseCommand('/teamback s' + s, true) |
|
728 |
end |
|
729 |
end |
|
10343
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset
|
730 |
else |
10665 | 731 |
begin |
10944
c4b3440eeac6
- Fix order of messages, also don't duplicate last timestamped message
unc0rr
parents:
10883
diff
changeset
|
732 |
//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
|
733 |
|
10398 | 734 |
if (not CurrentTeam^.ExtDriven) or (CurrentTeam^.TeamName = s) or (CurrentTeam^.hasGone) then |
10665 | 735 |
ParseCommand('/teamgone s' + s, true) |
736 |
end; |
|
10343
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset
|
737 |
end; |
4404 | 738 |
|
10343
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset
|
739 |
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
|
740 |
var t: LongInt; |
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset
|
741 |
isSynced: boolean; |
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset
|
742 |
begin |
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset
|
743 |
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
|
744 |
|
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset
|
745 |
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
|
746 |
|
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset
|
747 |
t:= 0; |
10665 | 748 |
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
|
749 |
inc(t); |
10665 | 750 |
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
|
751 |
exit; |
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset
|
752 |
|
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset
|
753 |
if isSynced then |
7119 | 754 |
begin |
10343
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset
|
755 |
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
|
756 |
if hasGone then |
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset
|
757 |
begin |
13156
26f0c3669b4e
Make a few more engine strings translatable
Wuzzy <Wuzzy2@mail.ru>
parents:
13140
diff
changeset
|
758 |
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
|
759 |
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
|
760 |
hasGone:= false; |
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset
|
761 |
|
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset
|
762 |
RecountTeamHealth(TeamsArray[t]); |
4404 | 763 |
|
10397 | 764 |
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
|
765 |
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
|
766 |
|
10397 | 767 |
isGoneFlagPendingToBeUnset:= false; |
10343
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset
|
768 |
end; |
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset
|
769 |
end |
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset
|
770 |
else |
10665 | 771 |
begin |
10397 | 772 |
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
|
773 |
|
10343
fe9853dea6c4
Finish implementation of ability to take control over your team after being disconnected. Completely untested.
unc0rr
parents:
10193
diff
changeset
|
774 |
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
|
775 |
ParseCommand('/teamback s' + s, true); |
10665 | 776 |
end; |
4404 | 777 |
end; |
778 |
||
779 |
||
7270
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset
|
780 |
procedure SwitchCurrentHedgehog(newHog: PHedgehog); |
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset
|
781 |
var oldCI, newCI: boolean; |
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset
|
782 |
oldHH: PHedgehog; |
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset
|
783 |
begin |
7755
b8958e64e68d
Also shove using shotgun, switch off hat when not active hog
nemo
parents:
7669
diff
changeset
|
784 |
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
|
785 |
LoadHedgehogHat(CurrentHedgehog^, CurrentHedgehog^.Hat); |
7270
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset
|
786 |
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
|
787 |
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
|
788 |
if oldCI then DeleteCI(CurrentHedgehog^.Gear); |
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset
|
789 |
if newCI then DeleteCI(newHog^.Gear); |
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset
|
790 |
oldHH:= CurrentHedgehog; |
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset
|
791 |
CurrentHedgehog:= newHog; |
9291
15f7bb217b66
Make add/delete consistent (this has bugged me for so long)
nemo
parents:
9285
diff
changeset
|
792 |
if oldCI then AddCI(oldHH^.Gear); |
15f7bb217b66
Make add/delete consistent (this has bugged me for so long)
nemo
parents:
9285
diff
changeset
|
793 |
if newCI then AddCI(newHog^.Gear) |
7270
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset
|
794 |
end; |
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset
|
795 |
|
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset
|
796 |
|
9790 | 797 |
procedure chSetHat(var s: shortstring); |
798 |
begin |
|
799 |
if (not isDeveloperMode) or (CurrentTeam = nil) then exit; |
|
800 |
with CurrentTeam^ do |
|
801 |
begin |
|
802 |
if not CurrentHedgehog^.King then |
|
803 |
if (s = '') |
|
804 |
or (((GameFlags and gfKing) <> 0) and (s = 'crown')) |
|
805 |
or ((Length(s) > 39) and (Copy(s,1,8) = 'Reserved') and (Copy(s,9,32) <> PlayerHash)) then |
|
806 |
CurrentHedgehog^.Hat:= 'NoHat' |
|
807 |
else |
|
808 |
CurrentHedgehog^.Hat:= s |
|
809 |
end; |
|
810 |
end; |
|
811 |
||
812 |
procedure chGrave(var s: shortstring); |
|
813 |
begin |
|
814 |
if CurrentTeam = nil then |
|
815 |
OutError(errmsgIncorrectUse + ' "/grave"', true); |
|
816 |
if s[1]='"' then |
|
817 |
Delete(s, 1, 1); |
|
818 |
if s[byte(s[0])]='"' then |
|
819 |
Delete(s, byte(s[0]), 1); |
|
820 |
CurrentTeam^.GraveName:= s |
|
821 |
end; |
|
822 |
||
823 |
procedure chFort(var s: shortstring); |
|
824 |
begin |
|
825 |
if CurrentTeam = nil then |
|
826 |
OutError(errmsgIncorrectUse + ' "/fort"', true); |
|
827 |
if s[1]='"' then |
|
828 |
Delete(s, 1, 1); |
|
829 |
if s[byte(s[0])]='"' then |
|
830 |
Delete(s, byte(s[0]), 1); |
|
831 |
CurrentTeam^.FortName:= s |
|
832 |
end; |
|
833 |
||
834 |
procedure chFlag(var s: shortstring); |
|
835 |
begin |
|
836 |
if CurrentTeam = nil then |
|
837 |
OutError(errmsgIncorrectUse + ' "/flag"', true); |
|
838 |
if s[1]='"' then |
|
839 |
Delete(s, 1, 1); |
|
840 |
if s[byte(s[0])]='"' then |
|
841 |
Delete(s, byte(s[0]), 1); |
|
842 |
CurrentTeam^.flag:= s |
|
843 |
end; |
|
844 |
||
845 |
procedure chOwner(var s: shortstring); |
|
846 |
begin |
|
847 |
if CurrentTeam = nil then |
|
848 |
OutError(errmsgIncorrectUse + ' "/owner"', true); |
|
849 |
||
850 |
CurrentTeam^.Owner:= s |
|
851 |
end; |
|
852 |
||
3038 | 853 |
procedure initModule; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
854 |
begin |
6898 | 855 |
RegisterVariable('addhh', @chAddHH, false); |
856 |
RegisterVariable('addteam', @chAddTeam, false); |
|
857 |
RegisterVariable('hhcoords', @chSetHHCoords, false); |
|
858 |
RegisterVariable('bind', @chBind, true ); |
|
859 |
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
|
860 |
RegisterVariable('teamback', @chTeamBack, true ); |
9790 | 861 |
RegisterVariable('fort' , @chFort , false); |
862 |
RegisterVariable('grave' , @chGrave , false); |
|
863 |
RegisterVariable('hat' , @chSetHat , false); |
|
864 |
RegisterVariable('flag' , @chFlag , false); |
|
865 |
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
|
866 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
867 |
CurrentTeam:= nil; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
868 |
PreviousTeam:= nil; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
869 |
CurrentHedgehog:= nil; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
870 |
TeamsCount:= 0; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
871 |
ClansCount:= 0; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
872 |
LocalClan:= -1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
873 |
LocalTeam:= -1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
874 |
LocalAmmo:= -1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
875 |
GameOver:= false; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
876 |
NextClan:= true; |
6982 | 877 |
MaxTeamHealth:= 0; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
878 |
end; |
4 | 879 |
|
3038 | 880 |
procedure freeModule; |
4881
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4514
diff
changeset
|
881 |
var i, h: LongWord; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
882 |
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
|
883 |
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
|
884 |
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
|
885 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
886 |
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
|
887 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
888 |
for h:= 0 to cMaxHHIndex do |
9468
3d07fd84c39d
- Actually call uTexture.initModule and .freeModule
unc0rr
parents:
9466
diff
changeset
|
889 |
with TeamsArray[i]^.Hedgehogs[h] do |
3d07fd84c39d
- Actually call uTexture.initModule and .freeModule
unc0rr
parents:
9466
diff
changeset
|
890 |
begin |
10646
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release 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
|
891 |
// if Gear <> nil then |
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release 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
|
892 |
// DeleteGearStage(Gear, true); |
9468
3d07fd84c39d
- Actually call uTexture.initModule and .freeModule
unc0rr
parents:
9466
diff
changeset
|
893 |
if GearHidden <> nil then |
10646
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release 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
|
894 |
Dispose(GearHidden); |
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about post-release 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 |
// DeleteGearStage(GearHidden, true); |
9655
e154ccca4dad
Tinted crosshair (without that cool white dot in the middle)
unc0rr
parents:
9468
diff
changeset
|
896 |
|
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
|
897 |
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
|
898 |
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
|
899 |
FreeAndNilTexture(HatTex) |
9468
3d07fd84c39d
- Actually call uTexture.initModule and .freeModule
unc0rr
parents:
9466
diff
changeset
|
900 |
end; |
9655
e154ccca4dad
Tinted crosshair (without that cool white dot in the middle)
unc0rr
parents:
9468
diff
changeset
|
901 |
|
9468
3d07fd84c39d
- Actually call uTexture.initModule and .freeModule
unc0rr
parents:
9466
diff
changeset
|
902 |
with TeamsArray[i]^ do |
3d07fd84c39d
- Actually call uTexture.initModule and .freeModule
unc0rr
parents:
9466
diff
changeset
|
903 |
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
|
904 |
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
|
905 |
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
|
906 |
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
|
907 |
FreeAndNilTexture(AIKillsTex); |
13018
0248cf0da834
Add SetTeamLabel to Lua API, can set arbitrary string as team label
Wuzzy <Wuzzy2@mail.ru>
parents:
12919
diff
changeset
|
908 |
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
|
909 |
FreeAndNilTexture(FlagTex); |
9468
3d07fd84c39d
- Actually call uTexture.initModule and .freeModule
unc0rr
parents:
9466
diff
changeset
|
910 |
end; |
9655
e154ccca4dad
Tinted crosshair (without that cool white dot in the middle)
unc0rr
parents:
9468
diff
changeset
|
911 |
|
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
|
912 |
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
|
913 |
end; |
9656 | 914 |
for i:= 0 to Pred(ClansCount) do |
915 |
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
|
916 |
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
|
917 |
Dispose(ClansArray[i]) |
9656 | 918 |
end |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
919 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
920 |
TeamsCount:= 0; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
921 |
ClansCount:= 0; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
922 |
end; |
4 | 923 |
|
924 |
end. |