author | Periklis Ntanasis <pntanasis@gmail.com> |
Mon, 05 Aug 2013 20:02:16 +0300 | |
branch | spacecampaign |
changeset 9471 | 867f020b0621 |
parent 9295 | f8819c3dde54 |
child 9407 | 860f959f92c9 |
permissions | -rw-r--r-- |
9285 | 1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
9080 | 3 |
* Copyright (c) 2004-2013 Andrey Korotaev <unC0Rr@gmail.com> |
4 | 4 |
* |
183 | 5 |
* This program is free software; you can redistribute it and/or modify |
6 |
* it under the terms of the GNU General Public License as published by |
|
7 |
* the Free Software Foundation; version 2 of the License |
|
4 | 8 |
* |
183 | 9 |
* This program is distributed in the hope that it will be useful, |
10 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
11 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
12 |
* GNU General Public License for more details. |
|
4 | 13 |
* |
183 | 14 |
* You should have received a copy of the GNU General Public License |
15 |
* along with this program; if not, write to the Free Software |
|
16 |
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA |
|
4 | 17 |
*) |
18 |
||
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 |
|
9285 | 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); |
8817
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset
|
37 |
procedure RestoreHog(HH: PHedgehog); |
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset
|
38 |
|
72 | 39 |
procedure RestoreTeamsFromSave; |
1058
c53c5c4e7b48
- Proper turns counting, split SwitchHedgehog into two functions
unc0rr
parents:
1011
diff
changeset
|
40 |
function CheckForWin: boolean; |
2040 | 41 |
procedure TeamGoneEffect(var Team: TTeam); |
7270
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset
|
42 |
procedure SwitchCurrentHedgehog(newHog: PHedgehog); |
4 | 43 |
|
44 |
implementation |
|
8370 | 45 |
uses uLocale, uAmmos, uChat, uVariables, uUtils, uIO, uCaptions, uCommands, uDebug, |
9283
76e68c136a11
Refactoring: VGSHandlers.inc -> uVisualGearsHandlers.pas
unc0rr
parents:
9224
diff
changeset
|
46 |
uGearsUtils, uGearsList, uVisualGearsList |
7837 | 47 |
{$IFDEF USE_TOUCH_INTERFACE}, uTouch{$ENDIF}; |
4377 | 48 |
|
6982 | 49 |
var MaxTeamHealth: LongInt; |
7028 | 50 |
GameOver: boolean; |
8145
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
8054
diff
changeset
|
51 |
NextClan: boolean; |
4 | 52 |
|
92
0c359a7a2356
- Fix win message to appear only after all hedgehogs death
unc0rr
parents:
89
diff
changeset
|
53 |
function CheckForWin: boolean; |
576 | 54 |
var AliveClan: PClan; |
306 | 55 |
s: shortstring; |
1011 | 56 |
t, AliveCount, i, j: LongInt; |
83 | 57 |
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
|
58 |
CheckForWin:= false; |
548 | 59 |
AliveCount:= 0; |
549 | 60 |
for t:= 0 to Pred(ClansCount) do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
61 |
if ClansArray[t]^.ClanHealth > 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
62 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
63 |
inc(AliveCount); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
64 |
AliveClan:= ClansArray[t] |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
65 |
end; |
548 | 66 |
|
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
|
67 |
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
|
68 |
exit; |
351 | 69 |
CheckForWin:= true; |
83 | 70 |
|
71 |
TurnTimeLeft:= 0; |
|
3774 | 72 |
ReadyTimeLeft:= 0; |
7669
a85e1c167b69
I didn't want to do this since it seems less clean, but...
sheepluva
parents:
7442
diff
changeset
|
73 |
|
a85e1c167b69
I didn't want to do this since it seems less clean, but...
sheepluva
parents:
7442
diff
changeset
|
74 |
// 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
|
75 |
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
|
76 |
TurnReaction(); |
a85e1c167b69
I didn't want to do this since it seems less clean, but...
sheepluva
parents:
7442
diff
changeset
|
77 |
|
4014
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset
|
78 |
if not GameOver then |
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset
|
79 |
begin |
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset
|
80 |
if AliveCount = 0 then |
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset
|
81 |
begin // draw |
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset
|
82 |
AddCaption(trmsg[sidDraw], cWhiteColor, capgrpGameState); |
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset
|
83 |
SendStat(siGameResult, trmsg[sidDraw]); |
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset
|
84 |
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
|
85 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
86 |
else // win |
4014
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset
|
87 |
with AliveClan^ do |
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset
|
88 |
begin |
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset
|
89 |
if TeamsNumber = 1 then |
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset
|
90 |
s:= Format(shortstring(trmsg[sidWinner]), Teams[0]^.TeamName) // team wins |
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset
|
91 |
else |
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset
|
92 |
s:= Format(shortstring(trmsg[sidWinner]), Teams[0]^.TeamName); // clan wins |
549 | 93 |
|
4014
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset
|
94 |
for j:= 0 to Pred(TeamsNumber) do |
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset
|
95 |
with Teams[j]^ do |
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset
|
96 |
for i:= 0 to cMaxHHIndex do |
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset
|
97 |
with Hedgehogs[i] do |
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset
|
98 |
if (Gear <> nil) then |
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset
|
99 |
Gear^.State:= gstWinner; |
4978 | 100 |
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
|
101 |
AddVoice(sndFlawless, Teams[0]^.voicepack) |
4978 | 102 |
else |
5638
e35ba2a400d8
Try to avoid overlapping voices for major statements (not things like byebye or oof)
nemo
parents:
5357
diff
changeset
|
103 |
AddVoice(sndVictory, Teams[0]^.voicepack); |
2376 | 104 |
|
4014
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset
|
105 |
AddCaption(s, cWhiteColor, capgrpGameState); |
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset
|
106 |
SendStat(siGameResult, s); |
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset
|
107 |
AddGear(0, 0, gtATFinishGame, 0, _0, _0, 3000) |
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset
|
108 |
end; |
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset
|
109 |
SendStats; |
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset
|
110 |
end; |
e9baae83370b
Avoid doing this stuff twice, even if CheckForWin is called twice
nemo
parents:
3996
diff
changeset
|
111 |
GameOver:= true |
83 | 112 |
end; |
113 |
||
4 | 114 |
procedure SwitchHedgehog; |
9137
d987230b85ed
fixed all engine compilation hints and notes (that I could see)
sheepluva
parents:
9080
diff
changeset
|
115 |
var c, i, t: LongWord; |
5052 | 116 |
PrevHH, PrevTeam : LongWord; |
4 | 117 |
begin |
118 |
TargetPoint.X:= NoPointX; |
|
89 | 119 |
TryDo(CurrentTeam <> nil, 'nil Team', true); |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2758
diff
changeset
|
120 |
with CurrentHedgehog^ do |
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2758
diff
changeset
|
121 |
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
|
122 |
begin |
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2758
diff
changeset
|
123 |
Unplaced:= false; |
3697 | 124 |
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
|
125 |
begin |
2763
f21d3ca74ef2
Do CI correctly. Still need to allow for mode in case of no teleports in ammo
nemo
parents:
2762
diff
changeset
|
126 |
DeleteCI(Gear); |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2758
diff
changeset
|
127 |
FindPlace(Gear, false, 0, LAND_WIDTH); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
128 |
if Gear <> nil then |
9291
15f7bb217b66
Make add/delete consistent (this has bugged me for so long)
nemo
parents:
9285
diff
changeset
|
129 |
AddCI(Gear) |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2758
diff
changeset
|
130 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
131 |
end; |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2758
diff
changeset
|
132 |
|
1678 | 133 |
PreviousTeam:= CurrentTeam; |
547 | 134 |
|
944 | 135 |
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
|
136 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
137 |
if Gear <> nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
138 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
139 |
MultiShootAttacks:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
140 |
Gear^.Message:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
141 |
Gear^.Z:= cHHZ; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
142 |
RemoveGearFromList(Gear); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
143 |
InsertGearToList(Gear) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
144 |
end |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2758
diff
changeset
|
145 |
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
|
146 |
// 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
|
147 |
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
|
148 |
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
|
149 |
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
|
150 |
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
|
151 |
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
|
152 |
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
|
153 |
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
|
154 |
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
|
155 |
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
|
156 |
end |
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
|
157 |
until (c = CurrHedgehog) or (Hedgehogs[c].Gear <> nil); |
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
|
158 |
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
|
159 |
end; |
4 | 160 |
|
550 | 161 |
c:= CurrentTeam^.Clan^.ClanIndex; |
4 | 162 |
repeat |
5021 | 163 |
with ClansArray[c]^ do |
6450 | 164 |
if (CurrTeam = TagTeamIndex) and ((GameFlags and gfTagTeam) <> 0) then |
5021 | 165 |
begin |
166 |
TagTeamIndex:= Pred(TagTeamIndex) mod TeamsNumber; |
|
167 |
CurrTeam:= Pred(CurrTeam) mod TeamsNumber; |
|
168 |
inc(c); |
|
169 |
NextClan:= true; |
|
170 |
end; |
|
171 |
||
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
172 |
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
|
173 |
inc(c); |
5016
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset
|
174 |
|
5021 | 175 |
if c = ClansCount then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
176 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
177 |
if not PlacingHogs then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
178 |
inc(TotalRounds); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
179 |
c:= 0 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
180 |
end; |
1058
c53c5c4e7b48
- Proper turns counting, split SwitchHedgehog into two functions
unc0rr
parents:
1011
diff
changeset
|
181 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
182 |
with ClansArray[c]^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
183 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
184 |
PrevTeam:= CurrTeam; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
185 |
repeat |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
186 |
CurrTeam:= Succ(CurrTeam) mod TeamsNumber; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
187 |
CurrentTeam:= Teams[CurrTeam]; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
188 |
with CurrentTeam^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
189 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
190 |
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
|
191 |
repeat |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
192 |
CurrHedgehog:= Succ(CurrHedgehog) mod HedgehogsNumber; |
9067 | 193 |
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
|
194 |
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
|
195 |
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
|
196 |
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
|
197 |
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
|
198 |
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
|
199 |
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
|
200 |
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
|
201 |
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
|
202 |
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
|
203 |
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
|
204 |
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
|
205 |
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
|
206 |
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
|
207 |
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
|
208 |
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
|
209 |
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
|
210 |
inc(CurrentTeam^.Clan^.TurnNumber); |
8935 | 211 |
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
|
212 |
until (CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog].Gear <> nil) and (CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog].Effects[heFrozen] < 256); |
83 | 213 |
|
7270
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset
|
214 |
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
|
215 |
{$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
|
216 |
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
|
217 |
begin |
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6622
diff
changeset
|
218 |
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
|
219 |
begin |
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6622
diff
changeset
|
220 |
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
|
221 |
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
|
222 |
end; |
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6622
diff
changeset
|
223 |
end |
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6622
diff
changeset
|
224 |
else |
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6622
diff
changeset
|
225 |
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
|
226 |
begin |
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6622
diff
changeset
|
227 |
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
|
228 |
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
|
229 |
end; |
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6622
diff
changeset
|
230 |
{$ENDIF} |
6622 | 231 |
AmmoMenuInvalidated:= true; |
1058
c53c5c4e7b48
- Proper turns counting, split SwitchHedgehog into two functions
unc0rr
parents:
1011
diff
changeset
|
232 |
end; |
c53c5c4e7b48
- Proper turns counting, split SwitchHedgehog into two functions
unc0rr
parents:
1011
diff
changeset
|
233 |
|
c53c5c4e7b48
- Proper turns counting, split SwitchHedgehog into two functions
unc0rr
parents:
1011
diff
changeset
|
234 |
procedure AfterSwitchHedgehog; |
5357
ec36f3d53f3c
Tiny optimization: convert smooth wind indicator change gear into visual gear
unc0rr
parents:
5167
diff
changeset
|
235 |
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
|
236 |
CurWeapon: PAmmo; |
6913 | 237 |
w: real; |
238 |
vg: PVisualGear; |
|
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
|
239 |
|
1058
c53c5c4e7b48
- Proper turns counting, split SwitchHedgehog into two functions
unc0rr
parents:
1011
diff
changeset
|
240 |
begin |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2758
diff
changeset
|
241 |
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
|
242 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
243 |
PlacingHogs:= false; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
244 |
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
|
245 |
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
|
246 |
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
|
247 |
PlacingHogs:= true; |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2758
diff
changeset
|
248 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
249 |
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
|
250 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
251 |
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
|
252 |
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
|
253 |
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
|
254 |
ResetWeapons |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
255 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
256 |
end; |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2758
diff
changeset
|
257 |
|
2431
23242609c44b
Real fix to ammo slot overflow (bug triggered by r2411 fix)
unc0rr
parents:
2376
diff
changeset
|
258 |
inc(CurrentTeam^.Clan^.TurnNumber); |
8935 | 259 |
with CurrentTeam^.Clan^ do |
260 |
for t:= 0 to Pred(TeamsNumber) do |
|
261 |
with Teams[t]^ do |
|
262 |
for i:= 0 to Pred(HedgehogsNumber) do |
|
263 |
with Hedgehogs[i] do |
|
264 |
if Effects[heFrozen] > 255 then |
|
265 |
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
|
266 |
|
6924 | 267 |
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
|
268 |
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
|
269 |
CurrentHedgehog^.CurAmmoType:= amNothing; |
2431
23242609c44b
Real fix to ammo slot overflow (bug triggered by r2411 fix)
unc0rr
parents:
2376
diff
changeset
|
270 |
|
602 | 271 |
with CurrentHedgehog^ do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
272 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
273 |
with Gear^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
274 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
275 |
Z:= cCurrHHZ; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
276 |
State:= gstHHDriven; |
5063 | 277 |
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
|
278 |
Power:= 0; |
5063 | 279 |
LastDamage:= nil |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
280 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
281 |
RemoveGearFromList(Gear); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
282 |
InsertGearToList(Gear); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
283 |
FollowGear:= Gear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
284 |
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
|
285 |
|
4218 | 286 |
if (GameFlags and gfDisableWind) = 0 then |
287 |
begin |
|
7001 | 288 |
cWindSpeed:= rndSign(GetRandomf * 2 * cMaxWindSpeed); |
6913 | 289 |
w:= hwFloat2Float(cWindSpeed); |
290 |
vg:= AddVisualGear(0, 0, vgtSmoothWindBar); |
|
291 |
if vg <> nil then vg^.dAngle:= w; |
|
4900 | 292 |
AddFileLog('Wind = '+FloatToStr(cWindSpeed)); |
4218 | 293 |
end; |
294 |
||
602 | 295 |
ApplyAmmoChanges(CurrentHedgehog^); |
800 | 296 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
297 |
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
|
298 |
SetBinds(CurrentTeam^.Binds); |
1650
a65681cc27c2
Don't fallback to default binds set when switching to remotely driven team
unc0rr
parents:
1495
diff
changeset
|
299 |
|
176 | 300 |
bShowFinger:= true; |
800 | 301 |
|
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2758
diff
changeset
|
302 |
if PlacingHogs then |
5016
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset
|
303 |
begin |
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 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
|
305 |
TurnTimeLeft:= 15000 |
5016
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset
|
306 |
else TurnTimeLeft:= 0 |
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset
|
307 |
end |
6450 | 308 |
else if ((GameFlags and gfTagTeam) <> 0) and (not NextClan) then |
5016
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset
|
309 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
310 |
if TagTurnTimeLeft <> 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
311 |
TurnTimeLeft:= TagTurnTimeLeft; |
5016
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset
|
312 |
TagTurnTimeLeft:= 0; |
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset
|
313 |
end |
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset
|
314 |
else |
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset
|
315 |
begin |
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset
|
316 |
TurnTimeLeft:= cHedgehogTurnTime; |
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset
|
317 |
TagTurnTimeLeft:= 0; |
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset
|
318 |
NextClan:= false; |
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset
|
319 |
end; |
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
|
320 |
|
3774 | 321 |
if (TurnTimeLeft > 0) and (CurrentHedgehog^.BotLevel = 0) then |
322 |
begin |
|
3798 | 323 |
if CurrentTeam^.ExtDriven then |
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
|
324 |
begin |
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
|
325 |
if GetRandom(2) = 0 then |
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
|
326 |
AddVoice(sndIllGetYou, CurrentTeam^.voicepack) |
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
|
327 |
else AddVoice(sndJustYouWait, CurrentTeam^.voicepack) |
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
|
328 |
end |
3798 | 329 |
else |
8054 | 330 |
begin |
331 |
GetRandom(2); // needed to avoid extdriven desync |
|
5638
e35ba2a400d8
Try to avoid overlapping voices for major statements (not things like byebye or oof)
nemo
parents:
5357
diff
changeset
|
332 |
AddVoice(sndYesSir, CurrentTeam^.voicepack); |
8054 | 333 |
end; |
6905 | 334 |
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
|
335 |
ReadyTimeLeft:= cReadyDelay; |
3799 | 336 |
AddCaption(Format(shortstring(trmsg[sidReady]), CurrentTeam^.TeamName), cWhiteColor, capgrpGameState) |
3774 | 337 |
end |
338 |
else |
|
3798 | 339 |
begin |
340 |
if TurnTimeLeft > 0 then |
|
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
|
341 |
begin |
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
|
342 |
if GetRandom(2) = 0 then |
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
|
343 |
AddVoice(sndIllGetYou, CurrentTeam^.voicepack) |
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
|
344 |
else AddVoice(sndJustYouWait, CurrentTeam^.voicepack) |
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
|
345 |
end; |
3798 | 346 |
ReadyTimeLeft:= 0 |
3952
d6412423da45
moved some utilities to a separate column with round buttons
koda
parents:
3935
diff
changeset
|
347 |
end; |
4 | 348 |
end; |
349 |
||
549 | 350 |
function AddTeam(TeamColor: Longword): PTeam; |
2695 | 351 |
var team: PTeam; |
8346 | 352 |
c, t: LongInt; |
4 | 353 |
begin |
1170 | 354 |
TryDo(TeamsCount < cMaxTeams, 'Too many teams', true); |
2695 | 355 |
New(team); |
356 |
TryDo(team <> nil, 'AddTeam: team = nil', true); |
|
357 |
FillChar(team^, sizeof(TTeam), 0); |
|
358 |
team^.AttackBar:= 2; |
|
2806 | 359 |
team^.CurrHedgehog:= 0; |
2747 | 360 |
team^.Flag:= 'hedgewars'; |
547 | 361 |
|
2695 | 362 |
TeamsArray[TeamsCount]:= team; |
547 | 363 |
inc(TeamsCount); |
364 |
||
8346 | 365 |
for t:= 0 to cKbdMaxIndex do |
366 |
team^.Binds[t]:= ''; |
|
367 |
||
549 | 368 |
c:= Pred(ClansCount); |
369 |
while (c >= 0) and (ClansArray[c]^.Color <> TeamColor) do dec(c); |
|
370 |
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
|
371 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
372 |
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
|
373 |
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
|
374 |
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
|
375 |
inc(ClansCount); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
376 |
with team^.Clan^ do |
549 | 377 |
begin |
550 | 378 |
ClanIndex:= Pred(ClansCount); |
3379 | 379 |
Color:= TeamColor; |
5016
9347d82a26cc
added game mode Tag Team, mostly untested, please test :)
Henek
parents:
4978
diff
changeset
|
380 |
TagTeamIndex:= 0; |
4978 | 381 |
Flawless:= true |
549 | 382 |
end |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
383 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
384 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
385 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
386 |
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
|
387 |
end; |
549 | 388 |
|
2695 | 389 |
with team^.Clan^ do |
549 | 390 |
begin |
2695 | 391 |
Teams[TeamsNumber]:= team; |
549 | 392 |
inc(TeamsNumber) |
393 |
end; |
|
394 |
||
2695 | 395 |
CurrentTeam:= team; |
396 |
AddTeam:= team; |
|
4 | 397 |
end; |
398 |
||
47 | 399 |
procedure RecountAllTeamsHealth; |
547 | 400 |
var t: LongInt; |
2376 | 401 |
begin |
547 | 402 |
for t:= 0 to Pred(TeamsCount) do |
403 |
RecountTeamHealth(TeamsArray[t]) |
|
47 | 404 |
end; |
405 |
||
406 |
procedure InitTeams; |
|
547 | 407 |
var i, t: LongInt; |
2784 | 408 |
th, h: LongInt; |
47 | 409 |
begin |
2726 | 410 |
|
547 | 411 |
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
|
412 |
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
|
413 |
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
|
414 |
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
|
415 |
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
|
416 |
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
|
417 |
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
|
418 |
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
|
419 |
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
|
420 |
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
|
421 |
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
|
422 |
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
|
423 |
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
|
424 |
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
|
425 |
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
|
426 |
// 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
|
427 |
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
|
428 |
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
|
429 |
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
|
430 |
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
|
431 |
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
|
432 |
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
|
433 |
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
|
434 |
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
|
435 |
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
|
436 |
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
|
437 |
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
|
438 |
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
|
439 |
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
|
440 |
end |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
441 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
442 |
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
|
443 |
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
|
444 |
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
|
445 |
end; |
2726 | 446 |
|
47 | 447 |
RecountAllTeamsHealth |
4 | 448 |
end; |
449 |
||
450 |
function TeamSize(p: PTeam): Longword; |
|
2695 | 451 |
var i, value: Longword; |
4 | 452 |
begin |
2695 | 453 |
value:= 0; |
4 | 454 |
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
|
455 |
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
|
456 |
inc(value); |
2695 | 457 |
TeamSize:= value; |
4 | 458 |
end; |
459 |
||
549 | 460 |
procedure RecountClanHealth(clan: PClan); |
461 |
var i: LongInt; |
|
462 |
begin |
|
463 |
with clan^ do |
|
464 |
begin |
|
465 |
ClanHealth:= 0; |
|
466 |
for i:= 0 to Pred(TeamsNumber) do |
|
467 |
inc(ClanHealth, Teams[i]^.TeamHealth) |
|
468 |
end |
|
469 |
end; |
|
470 |
||
47 | 471 |
procedure RecountTeamHealth(team: PTeam); |
371 | 472 |
var i: LongInt; |
47 | 473 |
begin |
474 |
with team^ do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
475 |
begin |
7990 | 476 |
TeamHealth:= 0; |
477 |
for i:= 0 to cMaxHHIndex do |
|
478 |
if Hedgehogs[i].Gear <> nil then |
|
479 |
inc(TeamHealth, Hedgehogs[i].Gear^.Health) |
|
480 |
else if Hedgehogs[i].GearHidden <> nil then |
|
481 |
inc(TeamHealth, Hedgehogs[i].GearHidden^.Health); |
|
2376 | 482 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
483 |
if not hasGone then |
7990 | 484 |
NewTeamHealthBarWidth:= TeamHealth |
485 |
else |
|
486 |
NewTeamHealthBarWidth:= 0; |
|
1352
405ad07cf875
Add more support for handling disconnects while playing (not fully tested)
unc0rr
parents:
1351
diff
changeset
|
487 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
488 |
if NewTeamHealthBarWidth > MaxTeamHealth then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
489 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
490 |
MaxTeamHealth:= NewTeamHealthBarWidth; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
491 |
RecountAllTeamsHealth; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
492 |
end else if NewTeamHealthBarWidth > 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
493 |
NewTeamHealthBarWidth:= (NewTeamHealthBarWidth * cTeamHealthWidth) div MaxTeamHealth |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
494 |
end; |
549 | 495 |
|
496 |
RecountClanHealth(team^.Clan); |
|
497 |
||
2005 | 498 |
AddVisualGear(0, 0, vgtTeamHealthSorter) |
47 | 499 |
end; |
500 |
||
8817
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset
|
501 |
procedure RestoreHog(HH: PHedgehog); |
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset
|
502 |
begin |
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset
|
503 |
HH^.Gear:=HH^.GearHidden; |
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset
|
504 |
HH^.GearHidden:= nil; |
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset
|
505 |
InsertGearToList(HH^.Gear); |
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset
|
506 |
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
|
507 |
AddCI(HH^.Gear); |
8817
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset
|
508 |
HH^.Gear^.Active:= true; |
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset
|
509 |
ScriptCall('onHogRestore', HH^.Gear^.Uid) |
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset
|
510 |
end; |
0d3014097240
move RestoreHog from uGears to uTeams to break a circular dependency
koda
parents:
8681
diff
changeset
|
511 |
|
72 | 512 |
procedure RestoreTeamsFromSave; |
547 | 513 |
var t: LongInt; |
72 | 514 |
begin |
547 | 515 |
for t:= 0 to Pred(TeamsCount) do |
516 |
TeamsArray[t]^.ExtDriven:= false |
|
72 | 517 |
end; |
518 |
||
2040 | 519 |
procedure TeamGoneEffect(var Team: TTeam); |
520 |
var i: LongInt; |
|
521 |
begin |
|
522 |
with Team do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
523 |
for i:= 0 to cMaxHHIndex do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
524 |
with Hedgehogs[i] do |
6131 | 525 |
begin |
526 |
if Hedgehogs[i].GearHidden <> nil then |
|
527 |
RestoreHog(@Hedgehogs[i]); |
|
528 |
||
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
529 |
if Gear <> nil then |
2826
fbcfc86ef477
Remove invulnerability protection from the team gone effect
nemo
parents:
2806
diff
changeset
|
530 |
begin |
fbcfc86ef477
Remove invulnerability protection from the team gone effect
nemo
parents:
2806
diff
changeset
|
531 |
Gear^.Invulnerable:= false; |
6131 | 532 |
Gear^.Damage:= Gear^.Health; |
7426
55b49cc1f33a
Changes for the benefit of pas2c. Use downto in for loops to avoid repeated calls of Random/GetRandom. Wrap nots.
nemo
parents:
7270
diff
changeset
|
533 |
Gear^.State:= (Gear^.State or gstHHGone) and (not gstHHDriven) |
2826
fbcfc86ef477
Remove invulnerability protection from the team gone effect
nemo
parents:
2806
diff
changeset
|
534 |
end |
6131 | 535 |
end |
2040 | 536 |
end; |
537 |
||
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
|
538 |
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
|
539 |
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
|
540 |
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
|
541 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
542 |
s:= ''; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
543 |
if (not isDeveloperMode) or (CurrentTeam = nil) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
544 |
exit; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
545 |
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
|
546 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
547 |
SplitBySpace(id, s); |
7270
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset
|
548 |
SwitchCurrentHedgehog(@Hedgehogs[HedgehogsNumber]); |
8370 | 549 |
CurrentHedgehog^.BotLevel:= StrToInt(id); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
550 |
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
|
551 |
SplitBySpace(s, id); |
8370 | 552 |
Gear^.Health:= StrToInt(s); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
553 |
TryDo(Gear^.Health > 0, 'Invalid hedgehog health', true); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
554 |
Gear^.Hedgehog^.Team:= CurrentTeam; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
555 |
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
|
556 |
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
|
557 |
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
|
558 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
559 |
AddAmmoStore; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
560 |
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
|
561 |
end |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
562 |
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
|
563 |
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
|
564 |
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
|
565 |
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
|
566 |
CurrHedgehog:= HedgehogsNumber; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
567 |
inc(HedgehogsNumber) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
568 |
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
|
569 |
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
|
570 |
|
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
|
571 |
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
|
572 |
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
|
573 |
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
|
574 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
575 |
cs:= ''; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
576 |
ts:= ''; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
577 |
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
|
578 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
579 |
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
|
580 |
SplitBySpace(cs, ts); |
8370 | 581 |
Color:= StrToInt(cs); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
582 |
TryDo(Color <> 0, 'Error: black team color', 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
|
583 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
584 |
// 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
|
585 |
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
|
586 |
AddTeam(Color); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
587 |
CurrentTeam^.TeamName:= ts; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
588 |
CurrentTeam^.PlayerHash:= s; |
7180 | 589 |
if GameType in [gmtDemo, gmtSave, gmtRecord] then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
590 |
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
|
591 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
592 |
CurrentTeam^.voicepack:= AskForVoicepack('Default') |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
593 |
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
|
594 |
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
|
595 |
|
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 |
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
|
597 |
var y: shortstring; |
8370 | 598 |
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
|
599 |
begin |
8370 | 600 |
y:= ''; |
601 |
if (not isDeveloperMode) or (CurrentHedgehog = nil) or (CurrentHedgehog^.Gear = nil) then |
|
602 |
exit; |
|
603 |
SplitBySpace(x, y); |
|
604 |
t:= StrToInt(x); |
|
605 |
CurrentHedgehog^.Gear^.X:= int2hwFloat(t); |
|
606 |
t:= StrToInt(y); |
|
607 |
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
|
608 |
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
|
609 |
|
4401 | 610 |
procedure chBind(var id: shortstring); |
7191
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
611 |
var KeyName, Modifier, tmp: shortstring; |
4401 | 612 |
b: LongInt; |
613 |
begin |
|
7191
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
614 |
KeyName:= ''; |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
615 |
Modifier:= ''; |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
616 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
617 |
if CurrentTeam = nil then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
618 |
exit; |
7191
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
619 |
|
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
620 |
if(Pos('mod:', id) <> 0)then |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
621 |
begin |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
622 |
tmp:= ''; |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
623 |
SplitBySpace(id, tmp); |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
624 |
Modifier:= id; |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
625 |
id:= tmp; |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
626 |
end; |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
627 |
|
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
628 |
SplitBySpace(id, KeyName); |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
629 |
if KeyName[1]='"' then |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
630 |
Delete(KeyName, 1, 1); |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
631 |
if KeyName[byte(KeyName[0])]='"' then |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
632 |
Delete(KeyName, byte(KeyName[0]), 1); |
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
633 |
b:= KeyNameToCode(id, Modifier); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
634 |
if b = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
635 |
OutError(errmsgUnknownVariable + ' "' + id + '"', false) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
636 |
else |
7191
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7184
diff
changeset
|
637 |
CurrentTeam^.Binds[b]:= KeyName; |
4401 | 638 |
end; |
639 |
||
4404 | 640 |
procedure chTeamGone(var s:shortstring); |
5832
f730c8a9777b
Remove some unused variables and options.inc which uFloat doesn't use, probably should never use, and was getting in the way of my testcase - but most importantly, remove the inline on hwSqrt which was causing very bad math on my compiler/machine. We may have to remove more inlining. A pity.
nemo
parents:
5829
diff
changeset
|
641 |
var t: LongInt; |
4404 | 642 |
begin |
643 |
t:= 0; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
644 |
while (t < cMaxTeams) and (TeamsArray[t] <> nil) and (TeamsArray[t]^.TeamName <> s) do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
645 |
inc(t); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
646 |
if (t = cMaxTeams) or (TeamsArray[t] = nil) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
647 |
exit; |
4404 | 648 |
|
649 |
with TeamsArray[t]^ do |
|
7119 | 650 |
if not hasGone then |
651 |
begin |
|
652 |
AddChatString('** '+ TeamName + ' is gone'); |
|
653 |
hasGone:= true; |
|
4404 | 654 |
|
7119 | 655 |
RecountTeamHealth(TeamsArray[t]) |
656 |
end; |
|
4404 | 657 |
end; |
658 |
||
659 |
||
6211
ee9465c0ea82
move (prematurely) finishing game by removing all teams into engine since that's where it should happen
sheepluva
parents:
6131
diff
changeset
|
660 |
procedure chFinish(var s:shortstring); |
ee9465c0ea82
move (prematurely) finishing game by removing all teams into engine since that's where it should happen
sheepluva
parents:
6131
diff
changeset
|
661 |
var t: LongInt; |
ee9465c0ea82
move (prematurely) finishing game by removing all teams into engine since that's where it should happen
sheepluva
parents:
6131
diff
changeset
|
662 |
begin |
ee9465c0ea82
move (prematurely) finishing game by removing all teams into engine since that's where it should happen
sheepluva
parents:
6131
diff
changeset
|
663 |
// avoid compiler hint |
ee9465c0ea82
move (prematurely) finishing game by removing all teams into engine since that's where it should happen
sheepluva
parents:
6131
diff
changeset
|
664 |
s:= s; |
ee9465c0ea82
move (prematurely) finishing game by removing all teams into engine since that's where it should happen
sheepluva
parents:
6131
diff
changeset
|
665 |
|
ee9465c0ea82
move (prematurely) finishing game by removing all teams into engine since that's where it should happen
sheepluva
parents:
6131
diff
changeset
|
666 |
t:= 0; |
ee9465c0ea82
move (prematurely) finishing game by removing all teams into engine since that's where it should happen
sheepluva
parents:
6131
diff
changeset
|
667 |
while (t < cMaxTeams) and (TeamsArray[t] <> nil) do |
ee9465c0ea82
move (prematurely) finishing game by removing all teams into engine since that's where it should happen
sheepluva
parents:
6131
diff
changeset
|
668 |
begin |
ee9465c0ea82
move (prematurely) finishing game by removing all teams into engine since that's where it should happen
sheepluva
parents:
6131
diff
changeset
|
669 |
TeamsArray[t]^.hasGone:= true; |
ee9465c0ea82
move (prematurely) finishing game by removing all teams into engine since that's where it should happen
sheepluva
parents:
6131
diff
changeset
|
670 |
inc(t); |
ee9465c0ea82
move (prematurely) finishing game by removing all teams into engine since that's where it should happen
sheepluva
parents:
6131
diff
changeset
|
671 |
end; |
ee9465c0ea82
move (prematurely) finishing game by removing all teams into engine since that's where it should happen
sheepluva
parents:
6131
diff
changeset
|
672 |
|
ee9465c0ea82
move (prematurely) finishing game by removing all teams into engine since that's where it should happen
sheepluva
parents:
6131
diff
changeset
|
673 |
AddChatString('** Good-bye!'); |
ee9465c0ea82
move (prematurely) finishing game by removing all teams into engine since that's where it should happen
sheepluva
parents:
6131
diff
changeset
|
674 |
RecountAllTeamsHealth(); |
ee9465c0ea82
move (prematurely) finishing game by removing all teams into engine since that's where it should happen
sheepluva
parents:
6131
diff
changeset
|
675 |
end; |
ee9465c0ea82
move (prematurely) finishing game by removing all teams into engine since that's where it should happen
sheepluva
parents:
6131
diff
changeset
|
676 |
|
7270
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset
|
677 |
procedure SwitchCurrentHedgehog(newHog: PHedgehog); |
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset
|
678 |
var oldCI, newCI: boolean; |
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset
|
679 |
oldHH: PHedgehog; |
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset
|
680 |
begin |
7755
b8958e64e68d
Also shove using shotgun, switch off hat when not active hog
nemo
parents:
7669
diff
changeset
|
681 |
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
|
682 |
LoadHedgehogHat(CurrentHedgehog^, CurrentHedgehog^.Hat); |
7270
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset
|
683 |
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
|
684 |
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
|
685 |
if oldCI then DeleteCI(CurrentHedgehog^.Gear); |
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset
|
686 |
if newCI then DeleteCI(newHog^.Gear); |
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset
|
687 |
oldHH:= CurrentHedgehog; |
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset
|
688 |
CurrentHedgehog:= newHog; |
7755
b8958e64e68d
Also shove using shotgun, switch off hat when not active hog
nemo
parents:
7669
diff
changeset
|
689 |
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
|
690 |
LoadHedgehogHat(CurrentHedgehog^, 'Reserved/chef'); |
9291
15f7bb217b66
Make add/delete consistent (this has bugged me for so long)
nemo
parents:
9285
diff
changeset
|
691 |
if oldCI then AddCI(oldHH^.Gear); |
15f7bb217b66
Make add/delete consistent (this has bugged me for so long)
nemo
parents:
9285
diff
changeset
|
692 |
if newCI then AddCI(newHog^.Gear) |
7270
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset
|
693 |
end; |
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset
|
694 |
|
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7191
diff
changeset
|
695 |
|
3038 | 696 |
procedure initModule; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
697 |
begin |
6898 | 698 |
RegisterVariable('addhh', @chAddHH, false); |
699 |
RegisterVariable('addteam', @chAddTeam, false); |
|
700 |
RegisterVariable('hhcoords', @chSetHHCoords, false); |
|
701 |
RegisterVariable('bind', @chBind, true ); |
|
702 |
RegisterVariable('teamgone', @chTeamGone, true ); |
|
703 |
RegisterVariable('finish', @chFinish, true ); // all teams gone |
|
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
|
704 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
705 |
CurrentTeam:= nil; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
706 |
PreviousTeam:= nil; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
707 |
CurrentHedgehog:= nil; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
708 |
TeamsCount:= 0; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
709 |
ClansCount:= 0; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
710 |
LocalClan:= -1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
711 |
LocalTeam:= -1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
712 |
LocalAmmo:= -1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
713 |
GameOver:= false; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
714 |
NextClan:= true; |
6982 | 715 |
MaxTeamHealth:= 0; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
716 |
end; |
4 | 717 |
|
3038 | 718 |
procedure freeModule; |
4881
35e6269227b6
still in developement take on adding structures, working hiding of hogs and ejecting them later.
Henek
parents:
4514
diff
changeset
|
719 |
var i, h: LongWord; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
720 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
721 |
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
|
722 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
723 |
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
|
724 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
725 |
for h:= 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
|
726 |
if TeamsArray[i]^.Hedgehogs[h].GearHidden <> nil then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
727 |
Dispose(TeamsArray[i]^.Hedgehogs[h].GearHidden); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
728 |
Dispose(TeamsArray[i]); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
729 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
730 |
for i:= 0 to Pred(ClansCount) do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
731 |
Dispose(ClansArray[i]); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
732 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
733 |
TeamsCount:= 0; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
734 |
ClansCount:= 0; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
735 |
end; |
4 | 736 |
|
737 |
end. |