author | Wuzzy <Wuzzy2@mail.ru> |
Fri, 30 Mar 2018 15:02:10 +0200 | |
changeset 13298 | 4e4c19ca63a8 |
parent 13214 | 9c81e34f1933 |
child 13319 | 78f097923bcb |
permissions | -rw-r--r-- |
4 | 1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
11046 | 3 |
* Copyright (c) 2004-2015 Andrey Korotaev <unC0Rr@gmail.com> |
4 | 4 |
* |
183 | 5 |
* This program is free software; you can redistribute it and/or modify |
6 |
* it under the terms of the GNU General Public License as published by |
|
7 |
* the Free Software Foundation; version 2 of the License |
|
4 | 8 |
* |
183 | 9 |
* This program is distributed in the hope that it will be useful, |
10 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
11 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
12 |
* GNU General Public License for more details. |
|
4 | 13 |
* |
183 | 14 |
* You should have received a copy of the GNU General Public License |
15 |
* along with this program; if not, write to the Free Software |
|
10108
c68cf030eded
update FSF address. note: two sdl include files (by Sam Lantinga) still have the old FSF address in their copyright - but I ain't gonna touch their copyright headers
sheepluva
parents:
10105
diff
changeset
|
16 |
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
4 | 17 |
*) |
18 |
||
2622 | 19 |
{$INCLUDE "options.inc"} |
20 |
||
4 | 21 |
unit uGears; |
5121
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
22 |
(* |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
23 |
* This unit defines the behavior of gears. |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
24 |
* |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
25 |
* Gears are "things"/"objects" that may be visible to the player or not, |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
26 |
* but always have an effect on the course of the game. |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
27 |
* |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
28 |
* E.g.: weapons, hedgehogs, etc. |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
29 |
* |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
30 |
* Note: The visual appearance of gears is defined in the unit "uGearsRender". |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
31 |
* |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
32 |
* Note: Gears that do not have an effect on the game but are just visual |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
33 |
* effects are called "Visual Gears" and defined in the respective unit! |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
34 |
*) |
4 | 35 |
interface |
10818
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
36 |
uses uConsts, uFloat, uTypes, uChat, uCollisions; |
3697 | 37 |
|
3038 | 38 |
procedure initModule; |
39 |
procedure freeModule; |
|
7337
c224cd2d32f3
Allow script to set number of ammo in a crate. untested.
nemo
parents:
7335
diff
changeset
|
40 |
function SpawnCustomCrateAt(x, y: LongInt; crate: TCrateType; content, cnt: Longword): PGear; |
5343 | 41 |
function SpawnFakeCrateAt(x, y: LongInt; crate: TCrateType; explode: boolean; poison: boolean ): PGear; |
4 | 42 |
procedure ProcessGears; |
3396
e5b3e5f2818e
More portal changes. Allows for a multishoot utility. Hopefully not breaking anything.
nemo
parents:
3390
diff
changeset
|
43 |
procedure EndTurnCleanup; |
956 | 44 |
procedure DrawGears; |
12210
442bab755bb4
Render gear timers in front of water
Wuzzy <almikes@aol.com>
parents:
12192
diff
changeset
|
45 |
procedure DrawGearsTimers; |
4 | 46 |
procedure FreeGearsList; |
10 | 47 |
procedure AddMiscGears; |
4 | 48 |
procedure AssignHHCoords; |
12918
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
49 |
procedure StartSuddenDeath; |
3405 | 50 |
function GearByUID(uid : Longword) : PGear; |
11916
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
51 |
function IsClockRunning() : boolean; |
4 | 52 |
|
53 |
implementation |
|
9651 | 54 |
uses uStore, uSound, uTeams, uRandom, uIO, uLandGraphics, |
55 |
{$IFDEF USE_TOUCH_INTERFACE}uTouch,{$ENDIF} |
|
9295
f8819c3dde54
Remove some GLunit dependencies noticed on graph. uUtils was using it for GLfloat - but, the stuff it was returning to was usually converting to "real" anyway. uLand was including it unnecessarily. Minor refactor
nemo
parents:
9293
diff
changeset
|
56 |
uLocale, uAmmos, uStats, uVisualGears, uScript, uVariables, |
12621 | 57 |
uCommands, uUtils, uTextures, uRenderUtils, uGearsRender, uCaptions, |
9285 | 58 |
uGearsHedgehog, uGearsUtils, uGearsList, uGearsHandlersRope |
9293
873022596d15
You better test build before committing even trivial patches
unc0rr
parents:
9291
diff
changeset
|
59 |
, uVisualGearsList, uGearsHandlersMess, uAI; |
789 | 60 |
|
7028 | 61 |
var skipFlag: boolean; |
3697 | 62 |
|
6982 | 63 |
var delay: LongWord; |
64 |
delay2: LongWord; |
|
12928 | 65 |
step: (stInit, stDelay, stChDmg, stSweep, stTurnReact, |
6982 | 66 |
stAfterDelay, stChWin, stWater, stChWin2, stHealth, |
67 |
stSpawn, stNTurn); |
|
8349
a1dbe148f10f
move onNewTurn, onGameTick and onGameTick20 to try and avoid ParseCommand breakage after nextturn call. Needs testing, but should be safe for most scripts. Also fix locale loading.
nemo
parents:
8204
diff
changeset
|
68 |
NewTurnTick: LongWord; |
7021
0c75512a8920
adjust the scope of a few uSound variables and functions
koda
parents:
7010
diff
changeset
|
69 |
//SDMusic: shortstring; |
6982 | 70 |
|
4 | 71 |
function CheckNoDamage: boolean; // returns TRUE in case of no damaged hhs |
72 |
var Gear: PGear; |
|
1849 | 73 |
dmg: LongInt; |
4 | 74 |
begin |
351 | 75 |
CheckNoDamage:= true; |
4 | 76 |
Gear:= GearsList; |
77 |
while Gear <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
78 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
79 |
if (Gear^.Kind = gtHedgehog) and (((GameFlags and gfInfAttack) = 0) or ((Gear^.dX.QWordValue < _0_000004.QWordValue) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
80 |
and (Gear^.dY.QWordValue < _0_000004.QWordValue))) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
81 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
82 |
if (not isInMultiShoot) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
83 |
inc(Gear^.Damage, Gear^.Karma); |
9685
7d925e82e572
Tweak trophyrace to work better w/ skip (probably, needs testing), drop Invulnerable in favour of effects - heInvulnerable is already in effects,
nemo
parents:
9672
diff
changeset
|
84 |
if (Gear^.Damage <> 0) and ((Gear^.Hedgehog^.Effects[heInvulnerable] = 0)) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
85 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
86 |
CheckNoDamage:= false; |
4824 | 87 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
88 |
dmg:= Gear^.Damage; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
89 |
if Gear^.Health < dmg then |
3453 | 90 |
begin |
91 |
Gear^.Active:= true; |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
92 |
Gear^.Health:= 0 |
3453 | 93 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
94 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
95 |
dec(Gear^.Health, dmg); |
7882
35dfc54ba2c6
disable this block since it doesn't fit star's new graphic. doesn't show up often anyway, since unc0rr changed gst clearing
nemo
parents:
7850
diff
changeset
|
96 |
(* |
35dfc54ba2c6
disable this block since it doesn't fit star's new graphic. doesn't show up often anyway, since unc0rr changed gst clearing
nemo
parents:
7850
diff
changeset
|
97 |
This doesn't fit well w/ the new loser sprite which is cringing from an attack. |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
98 |
if (Gear^.Hedgehog^.Team = CurrentTeam) and (Gear^.Damage <> Gear^.Karma) |
7010
10a0a31804f3
Switch effects to longint for convenience of tracking ice states. I could add a new Hedgehog value, but since we have this effects list being all useless as booleans anyway...
nemo
parents:
7007
diff
changeset
|
99 |
and (not Gear^.Hedgehog^.King) and (Gear^.Hedgehog^.Effects[hePoisoned] = 0) and (not SuddenDeathDmg) then |
2017 | 100 |
Gear^.State:= Gear^.State or gstLoser; |
7882
35dfc54ba2c6
disable this block since it doesn't fit star's new graphic. doesn't show up often anyway, since unc0rr changed gst clearing
nemo
parents:
7850
diff
changeset
|
101 |
*) |
2017 | 102 |
|
3461
0781275649e9
revert the restoration of non-vgt health gears. desyncs continued with it, and furthermore, occur in r3489 too
nemo
parents:
3460
diff
changeset
|
103 |
spawnHealthTagForHH(Gear, dmg); |
867 | 104 |
|
4365 | 105 |
RenderHealth(Gear^.Hedgehog^); |
106 |
RecountTeamHealth(Gear^.Hedgehog^.Team); |
|
1505 | 107 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
108 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
109 |
if (not isInMultiShoot) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
110 |
Gear^.Karma:= 0; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
111 |
Gear^.Damage:= 0 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
112 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
113 |
Gear:= Gear^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
114 |
end; |
4 | 115 |
end; |
116 |
||
1054 | 117 |
procedure HealthMachine; |
118 |
var Gear: PGear; |
|
2824
2d25e49bc2e8
Extra incentive to attack non-king hogs. If king loses his entourage, he loses 5hp per turn
nemo
parents:
2814
diff
changeset
|
119 |
team: PTeam; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
120 |
i: LongWord; |
2824
2d25e49bc2e8
Extra incentive to attack non-king hogs. If king loses his entourage, he loses 5hp per turn
nemo
parents:
2814
diff
changeset
|
121 |
flag: Boolean; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
122 |
tmp: LongWord; |
1054 | 123 |
begin |
3682 | 124 |
Gear:= GearsList; |
1054 | 125 |
|
3682 | 126 |
while Gear <> nil do |
127 |
begin |
|
128 |
if Gear^.Kind = gtHedgehog then |
|
129 |
begin |
|
130 |
tmp:= 0; |
|
11867 | 131 |
if (Gear^.Hedgehog^.Effects[hePoisoned] <> 0) and (Gear^.Hedgehog^.Effects[heFrozen] = 0) then |
4111 | 132 |
begin |
10012
82dd9f0c88f7
Make poison damage possibly variable (might as well since effects is a count). Scripts might find it handy.
nemo
parents:
9998
diff
changeset
|
133 |
inc(tmp, ModifyDamage(Gear^.Hedgehog^.Effects[hePoisoned], Gear)); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
134 |
if (GameFlags and gfResetHealth) <> 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
135 |
dec(Gear^.Hedgehog^.InitialHealth) // does not need a minimum check since <= 1 basically disables it |
4111 | 136 |
end; |
12918
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
137 |
// Apply SD health decrease as soon as SD starts |
4153
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
138 |
if (TotalRounds > cSuddenDTurns - 1) then |
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
139 |
begin |
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
140 |
inc(tmp, cHealthDecrease); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
141 |
if (GameFlags and gfResetHealth) <> 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
142 |
dec(Gear^.Hedgehog^.InitialHealth, cHealthDecrease) |
4153
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
143 |
end; |
4365 | 144 |
if Gear^.Hedgehog^.King then |
3109
06c089cb739c
Reduce turns to -1 to allow processing health machine on first turn. Needs testing with Sudden Death set to 0
nemo
parents:
3107
diff
changeset
|
145 |
begin |
06c089cb739c
Reduce turns to -1 to allow processing health machine on first turn. Needs testing with Sudden Death set to 0
nemo
parents:
3107
diff
changeset
|
146 |
flag:= false; |
4365 | 147 |
team:= Gear^.Hedgehog^.Team; |
3109
06c089cb739c
Reduce turns to -1 to allow processing health machine on first turn. Needs testing with Sudden Death set to 0
nemo
parents:
3107
diff
changeset
|
148 |
for i:= 0 to Pred(team^.HedgehogsNumber) do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
149 |
if (team^.Hedgehogs[i].Gear <> nil) and (not team^.Hedgehogs[i].King) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
150 |
and (team^.Hedgehogs[i].Gear^.Health > team^.Hedgehogs[i].Gear^.Damage) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
151 |
flag:= true; |
4111 | 152 |
if not flag then |
153 |
begin |
|
154 |
inc(tmp, 5); |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
155 |
if (GameFlags and gfResetHealth) <> 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
156 |
dec(Gear^.Hedgehog^.InitialHealth, 5) |
4111 | 157 |
end |
3109
06c089cb739c
Reduce turns to -1 to allow processing health machine on first turn. Needs testing with Sudden Death set to 0
nemo
parents:
3107
diff
changeset
|
158 |
end; |
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset
|
159 |
if tmp > 0 then |
3845
90034acb2e43
Untested fix of r3672 - should avoid hogs dying due to multiple health machine sources, and inappropriate application of karma/vampirism to these.
nemo
parents:
3836
diff
changeset
|
160 |
begin |
90034acb2e43
Untested fix of r3672 - should avoid hogs dying due to multiple health machine sources, and inappropriate application of karma/vampirism to these.
nemo
parents:
3836
diff
changeset
|
161 |
inc(Gear^.Damage, min(tmp, max(0,Gear^.Health - 1 - Gear^.Damage))); |
90034acb2e43
Untested fix of r3672 - should avoid hogs dying due to multiple health machine sources, and inappropriate application of karma/vampirism to these.
nemo
parents:
3836
diff
changeset
|
162 |
HHHurt(Gear^.Hedgehog, dsPoison); |
90034acb2e43
Untested fix of r3672 - should avoid hogs dying due to multiple health machine sources, and inappropriate application of karma/vampirism to these.
nemo
parents:
3836
diff
changeset
|
163 |
end |
3682 | 164 |
end; |
1054 | 165 |
|
3682 | 166 |
Gear:= Gear^.NextGear |
167 |
end; |
|
1054 | 168 |
end; |
169 |
||
4 | 170 |
procedure ProcessGears; |
7395 | 171 |
var t: PGear; |
4207
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
172 |
i, AliveCount: LongInt; |
10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10116
diff
changeset
|
173 |
s: ansistring; |
9672
8663d299ba62
this should prevent sliding when game clock isn't running. sorry unc0rr, not going to bother encapsulating. maybe later. short on time right now/lazy
nemo
parents:
9651
diff
changeset
|
174 |
prevtime: LongWord; |
11469 | 175 |
stirFallers: boolean; |
4 | 176 |
begin |
11469 | 177 |
stirFallers:= false; |
9672
8663d299ba62
this should prevent sliding when game clock isn't running. sorry unc0rr, not going to bother encapsulating. maybe later. short on time right now/lazy
nemo
parents:
9651
diff
changeset
|
178 |
prevtime:= TurnTimeLeft; |
8349
a1dbe148f10f
move onNewTurn, onGameTick and onGameTick20 to try and avoid ParseCommand breakage after nextturn call. Needs testing, but should be safe for most scripts. Also fix locale loading.
nemo
parents:
8204
diff
changeset
|
179 |
ScriptCall('onGameTick'); |
a1dbe148f10f
move onNewTurn, onGameTick and onGameTick20 to try and avoid ParseCommand breakage after nextturn call. Needs testing, but should be safe for most scripts. Also fix locale loading.
nemo
parents:
8204
diff
changeset
|
180 |
if GameTicks mod 20 = 0 then ScriptCall('onGameTick20'); |
8351 | 181 |
if GameTicks = NewTurnTick then |
182 |
begin |
|
183 |
ScriptCall('onNewTurn'); |
|
9651 | 184 |
{$IFDEF USE_TOUCH_INTERFACE} |
8351 | 185 |
uTouch.NewTurnBeginning(); |
186 |
{$ENDIF} |
|
187 |
end; |
|
8349
a1dbe148f10f
move onNewTurn, onGameTick and onGameTick20 to try and avoid ParseCommand breakage after nextturn call. Needs testing, but should be safe for most scripts. Also fix locale loading.
nemo
parents:
8204
diff
changeset
|
188 |
|
868 | 189 |
PrvInactive:= AllInactive; |
4 | 190 |
AllInactive:= true; |
1495 | 191 |
|
2940 | 192 |
if (StepSoundTimer > 0) and (StepSoundChannel < 0) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
193 |
StepSoundChannel:= LoopSound(sndSteps) |
2940 | 194 |
else if (StepSoundTimer = 0) and (StepSoundChannel > -1) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
195 |
begin |
7053 | 196 |
StopSoundChan(StepSoundChannel); |
2993
d83edb74e92d
Remove animation on jumping/resuming walk, only leave it in on weapon switch
nemo
parents:
2991
diff
changeset
|
197 |
StepSoundChannel:= -1 |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
198 |
end; |
2940 | 199 |
|
200 |
if StepSoundTimer > 0 then |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
201 |
dec(StepSoundTimer, 1); |
2940 | 202 |
|
4 | 203 |
t:= GearsList; |
1054 | 204 |
while t <> nil do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
205 |
begin |
7395 | 206 |
curHandledGear:= t; |
207 |
t:= curHandledGear^.NextGear; |
|
11469 | 208 |
if (GameTicks and $1FFF = 0) and (curHandledGear^.Kind = gtCase) and (curHandledGear^.Pos <> posCaseHealth) then |
209 |
stirFallers := true; |
|
3123 | 210 |
|
7517 | 211 |
if curHandledGear^.Message and gmDelete <> 0 then |
7519 | 212 |
DeleteGear(curHandledGear) |
213 |
else |
|
2204
526f8165acce
Smaxx' idea of timers, reworked just a tad. Might need variable for offset, but seems ok for now
nemo
parents:
2186
diff
changeset
|
214 |
begin |
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset
|
215 |
if curHandledGear^.Message and gmRemoveFromList <> 0 then |
7519 | 216 |
begin |
217 |
RemoveGearFromList(curHandledGear); |
|
218 |
// since I can't think of any good reason this would ever be separate from a remove from list, going to keep it inside this block |
|
219 |
if curHandledGear^.Message and gmAddToList <> 0 then InsertGearToList(curHandledGear); |
|
220 |
curHandledGear^.Message:= curHandledGear^.Message and (not (gmRemoveFromList or gmAddToList)) |
|
221 |
end; |
|
222 |
if curHandledGear^.Active then |
|
2204
526f8165acce
Smaxx' idea of timers, reworked just a tad. Might need variable for offset, but seems ok for now
nemo
parents:
2186
diff
changeset
|
223 |
begin |
7519 | 224 |
if curHandledGear^.RenderTimer and (curHandledGear^.Timer > 500) and ((curHandledGear^.Timer mod 1000) = 0) then |
225 |
begin |
|
10634
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10510
diff
changeset
|
226 |
FreeAndNilTexture(curHandledGear^.Tex); |
10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10116
diff
changeset
|
227 |
curHandledGear^.Tex:= RenderStringTex(ansistring(inttostr(curHandledGear^.Timer div 1000)), cWhiteColor, fntSmall); |
7519 | 228 |
end; |
229 |
curHandledGear^.doStep(curHandledGear); |
|
230 |
// might be useful later |
|
231 |
//ScriptCall('onGearStep', Gear^.uid); |
|
232 |
end |
|
2204
526f8165acce
Smaxx' idea of timers, reworked just a tad. Might need variable for offset, but seems ok for now
nemo
parents:
2186
diff
changeset
|
233 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
234 |
end; |
11469 | 235 |
if stirFallers then |
236 |
begin |
|
237 |
t := GearsList; |
|
238 |
while t <> nil do |
|
239 |
begin |
|
13214
9c81e34f1933
gtGenericFaller: Use Tag=1 to allow gtGenericFaller to be displaced randomly. Otherwise it is left alone
Wuzzy <Wuzzy2@mail.ru>
parents:
13171
diff
changeset
|
240 |
if (t^.Kind = gtGenericFaller) and (t^.Tag = 1) then |
11469 | 241 |
begin |
242 |
t^.Active:= true; |
|
243 |
t^.X:= int2hwFloat(GetRandom(rightX-leftX)+leftX); |
|
244 |
t^.Y:= int2hwFloat(GetRandom(LAND_HEIGHT-topY)+topY); |
|
245 |
t^.dX:= _90-(GetRandomf*_360); |
|
246 |
t^.dY:= _90-(GetRandomf*_360) |
|
247 |
end; |
|
248 |
t := t^.NextGear |
|
249 |
end |
|
250 |
end; |
|
251 |
||
7395 | 252 |
curHandledGear:= nil; |
89 | 253 |
|
4 | 254 |
if AllInactive then |
1343 | 255 |
case step of |
12928 | 256 |
stInit: |
257 |
begin |
|
13031
bef97cc310b0
Fix onEndTurn being called in multishoot
Wuzzy <Wuzzy2@mail.ru>
parents:
12938
diff
changeset
|
258 |
if (not bBetweenTurns) and (not isInMultiShoot) then |
bef97cc310b0
Fix onEndTurn being called in multishoot
Wuzzy <Wuzzy2@mail.ru>
parents:
12938
diff
changeset
|
259 |
ScriptCall('onEndTurn'); |
12928 | 260 |
inc(step) |
261 |
end; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
262 |
stDelay: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
263 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
264 |
if delay = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
265 |
delay:= cInactDelay |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
266 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
267 |
dec(delay); |
614 | 268 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
269 |
if delay = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
270 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
271 |
end; |
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset
|
272 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
273 |
stChDmg: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
274 |
if CheckNoDamage then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
275 |
inc(step) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
276 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
277 |
step:= stDelay; |
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset
|
278 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
279 |
stSweep: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
280 |
if SweepDirty then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
281 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
282 |
SetAllToActive; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
283 |
step:= stChDmg |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
284 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
285 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
286 |
inc(step); |
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset
|
287 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
288 |
stTurnReact: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
289 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
290 |
if (not bBetweenTurns) and (not isInMultiShoot) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
291 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
292 |
uStats.TurnReaction; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
293 |
inc(step) |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
294 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
295 |
else |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
296 |
inc(step, 2); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
297 |
end; |
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset
|
298 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
299 |
stAfterDelay: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
300 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
301 |
if delay = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
302 |
delay:= cInactDelay |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
303 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
304 |
dec(delay); |
815 | 305 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
306 |
if delay = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
307 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
308 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
309 |
stChWin: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
310 |
begin |
7669
a85e1c167b69
I didn't want to do this since it seems less clean, but...
sheepluva
parents:
7667
diff
changeset
|
311 |
CheckForWin(); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
312 |
inc(step) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
313 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
314 |
stWater: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
315 |
if (not bBetweenTurns) and (not isInMultiShoot) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
316 |
begin |
12918
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
317 |
// Start Sudden Death water rise in the 2nd round of Sudden Death |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
318 |
if TotalRounds = cSuddenDTurns + 1 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
319 |
bWaterRising:= true; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
320 |
if bWaterRising and (cWaterRise > 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
321 |
AddGear(0, 0, gtWaterUp, 0, _0, _0, 0)^.Tag:= cWaterRise; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
322 |
inc(step) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
323 |
end |
7667
4346566c5a58
skip second CheckForWin if water wasn't raised after first one
sheepluva
parents:
7666
diff
changeset
|
324 |
else // since we are not raising the water, a second win-check isn't needed |
4346566c5a58
skip second CheckForWin if water wasn't raised after first one
sheepluva
parents:
7666
diff
changeset
|
325 |
inc(step,2); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
326 |
stChWin2: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
327 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
328 |
CheckForWin; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
329 |
inc(step) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
330 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
331 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
332 |
stHealth: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
333 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
334 |
if (cWaterRise <> 0) or (cHealthDecrease <> 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
335 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
336 |
if (TotalRounds = cSuddenDTurns) and (not SuddenDeath) and (not isInMultiShoot) then |
12918
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
337 |
StartSuddenDeath() |
10254 | 338 |
else if (TotalRounds < cSuddenDTurns) and (not isInMultiShoot) then |
339 |
begin |
|
340 |
i:= cSuddenDTurns - TotalRounds; |
|
341 |
s:= ansistring(inttostr(i)); |
|
342 |
if i = 1 then |
|
343 |
AddCaption(trmsg[sidRoundSD], cWhiteColor, capgrpGameState) |
|
344 |
else if (i = 2) or ((i > 0) and ((i mod 50 = 0) or ((i <= 25) and (i mod 5 = 0)))) then |
|
345 |
AddCaption(FormatA(trmsg[sidRoundsSD], s), cWhiteColor, capgrpGameState); |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
346 |
end; |
10254 | 347 |
end; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
348 |
if bBetweenTurns |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
349 |
or isInMultiShoot |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
350 |
or (TotalRounds = -1) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
351 |
inc(step) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
352 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
353 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
354 |
bBetweenTurns:= true; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
355 |
HealthMachine; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
356 |
step:= stChDmg |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
357 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
358 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
359 |
stSpawn: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
360 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
361 |
if not isInMultiShoot then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
362 |
SpawnBoxOfSmth; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
363 |
inc(step) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
364 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
365 |
stNTurn: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
366 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
367 |
if isInMultiShoot then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
368 |
isInMultiShoot:= false |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
369 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
370 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
371 |
// delayed till after 0.9.12 |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
372 |
// reset to default zoom |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
373 |
//ZoomValue:= ZoomDefault; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
374 |
with CurrentHedgehog^ do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
375 |
if (Gear <> nil) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
376 |
and ((Gear^.State and gstAttacked) = 0) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
377 |
and (MultiShootAttacks > 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
378 |
OnUsedAmmo(CurrentHedgehog^); |
3697 | 379 |
|
3396
e5b3e5f2818e
More portal changes. Allows for a multishoot utility. Hopefully not breaking anything.
nemo
parents:
3390
diff
changeset
|
380 |
EndTurnCleanup; |
2376 | 381 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
382 |
FreeActionsList; // could send -left, -right and similar commands, so should be called before /nextturn |
1298 | 383 |
|
7181
0791c1f2734c
Welp. We have a bit of a problem here. Reverting the move of nextturn. But this causes a desync in scripting unless we can find a better fix.
nemo
parents:
7174
diff
changeset
|
384 |
ParseCommand('/nextturn', true); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
385 |
SwitchHedgehog; |
1298 | 386 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
387 |
AfterSwitchHedgehog; |
8349
a1dbe148f10f
move onNewTurn, onGameTick and onGameTick20 to try and avoid ParseCommand breakage after nextturn call. Needs testing, but should be safe for most scripts. Also fix locale loading.
nemo
parents:
8204
diff
changeset
|
388 |
bBetweenTurns:= false; |
a1dbe148f10f
move onNewTurn, onGameTick and onGameTick20 to try and avoid ParseCommand breakage after nextturn call. Needs testing, but should be safe for most scripts. Also fix locale loading.
nemo
parents:
8204
diff
changeset
|
389 |
NewTurnTick:= GameTicks + 1 |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
390 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
391 |
step:= Low(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
392 |
end; |
3949
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
393 |
end |
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
394 |
else if ((GameFlags and gfInfAttack) <> 0) then |
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
395 |
begin |
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
396 |
if delay2 = 0 then |
5296
0bb518ad2da8
At mikade's request and w/ unc0rr's blessing, dramatically slash inactivity delay from 1.25s down to a tenth of a second.
nemo
parents:
5284
diff
changeset
|
397 |
delay2:= cInactDelay * 50 |
3949
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
398 |
else |
3957 | 399 |
begin |
3949
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
400 |
dec(delay2); |
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
401 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
402 |
if ((delay2 mod cInactDelay) = 0) and (CurrentHedgehog <> nil) and (CurrentHedgehog^.Gear <> nil) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
403 |
and (not CurrentHedgehog^.Unplaced) then |
5507
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5501
diff
changeset
|
404 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
405 |
if (CurrentHedgehog^.Gear^.State and gstAttacked <> 0) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
406 |
and (Ammoz[CurrentHedgehog^.CurAmmoType].Ammo.Propz and ammoprop_NeedTarget <> 0) then |
5507
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5501
diff
changeset
|
407 |
begin |
10818
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
408 |
CurrentHedgehog^.Gear^.State:= CurrentHedgehog^.Gear^.State or gstChooseTarget; |
5507
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5501
diff
changeset
|
409 |
isCursorVisible := true |
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5501
diff
changeset
|
410 |
end; |
6453
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6380
diff
changeset
|
411 |
CurrentHedgehog^.Gear^.State:= CurrentHedgehog^.Gear^.State and (not gstAttacked); |
5507
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5501
diff
changeset
|
412 |
end; |
3957 | 413 |
if delay2 = 0 then |
414 |
begin |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
415 |
if (CurrentHedgehog^.Gear <> nil) and (CurrentHedgehog^.Gear^.State and gstAttacked = 0) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
416 |
and (CurAmmoGear = nil) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
417 |
SweepDirty; |
9497 | 418 |
if (CurrentHedgehog^.Gear = nil) or (CurrentHedgehog^.Gear^.State and gstHHDriven = 0) or (CurrentHedgehog^.Gear^.Damage = 0) then |
419 |
CheckNoDamage; |
|
4207
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
420 |
AliveCount:= 0; // shorter version of check for win to allow typical step activity to proceed |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
421 |
for i:= 0 to Pred(ClansCount) do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
422 |
if ClansArray[i]^.ClanHealth > 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
423 |
inc(AliveCount); |
4207
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
424 |
if (AliveCount <= 1) and ((GameFlags and gfOneClanMode) = 0) then |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
425 |
begin |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
426 |
step:= stChDmg; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
427 |
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
|
428 |
TagTurnTimeLeft:= TurnTimeLeft; |
12322
9aa483762025
Fix sndBoring being played when force-ending turn due to victory
Wuzzy <almikes@aol.com>
parents:
12306
diff
changeset
|
429 |
GameOver:= true; |
4207
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
430 |
TurnTimeLeft:= 0 |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
431 |
end |
3957 | 432 |
end |
3949
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
433 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
434 |
end; |
15 | 435 |
|
4 | 436 |
if TurnTimeLeft > 0 then |
11916
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
437 |
if IsClockRunning() then |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
438 |
//(CurrentHedgehog^.CurAmmoType in [amShotgun, amDEagle, amSniperRifle]) |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
439 |
begin |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
440 |
if (cHedgehogTurnTime >= 10000) |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
441 |
and (CurrentHedgehog^.Gear <> nil) |
12181 | 442 |
and ((CurrentHedgehog^.Gear^.State and gstAttacked) = 0) |
443 |
and (not isGetAwayTime) then |
|
11916
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
444 |
if TurnTimeLeft = 5000 then |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
445 |
PlaySoundV(sndHurry, CurrentTeam^.voicepack) |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
446 |
else if TurnTimeLeft = 4000 then |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
447 |
PlaySound(sndCountdown4) |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
448 |
else if TurnTimeLeft = 3000 then |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
449 |
PlaySound(sndCountdown3) |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
450 |
else if TurnTimeLeft = 2000 then |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
451 |
PlaySound(sndCountdown2) |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
452 |
else if TurnTimeLeft = 1000 then |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
453 |
PlaySound(sndCountdown1); |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
454 |
if ReadyTimeLeft > 0 then |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
455 |
begin |
11921
b1782491f19c
Enable timer warning sounds in hog placement phase
Wuzzy <almikes@aol.com>
parents:
11918
diff
changeset
|
456 |
if (ReadyTimeLeft = 2000) and (LastVoice.snd = sndNone) and (not PlacingHogs) then |
11916
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
457 |
AddVoice(sndComeonthen, CurrentTeam^.voicepack); |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
458 |
dec(ReadyTimeLeft) |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
459 |
end |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
460 |
else |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
461 |
dec(TurnTimeLeft) |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
462 |
end; |
351 | 463 |
|
2621
956ff066f3a5
Fix desync when playing with AI via network, occuring in certain conditions
unc0rr
parents:
2619
diff
changeset
|
464 |
if skipFlag then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
465 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
466 |
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
|
467 |
TagTurnTimeLeft:= TurnTimeLeft; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
468 |
TurnTimeLeft:= 0; |
3784
75aa91bea32b
Extend statistics collection (TeamKills, TurnSkips, TeamDamage)
burp
parents:
3775
diff
changeset
|
469 |
skipFlag:= false; |
75aa91bea32b
Extend statistics collection (TeamKills, TurnSkips, TeamDamage)
burp
parents:
3775
diff
changeset
|
470 |
inc(CurrentHedgehog^.Team^.stats.TurnSkips); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
471 |
end; |
2621
956ff066f3a5
Fix desync when playing with AI via network, occuring in certain conditions
unc0rr
parents:
2619
diff
changeset
|
472 |
|
2134 | 473 |
if ((GameTicks and $FFFF) = $FFFF) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
474 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
475 |
if (not CurrentTeam^.ExtDriven) then |
5810 | 476 |
begin |
7068 | 477 |
SendIPC(_S'#'); |
5810 | 478 |
AddFileLog('hiTicks increment message sent') |
479 |
end; |
|
2134 | 480 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
481 |
if (not CurrentTeam^.ExtDriven) or CurrentTeam^.hasGone then |
10395
0d20f6fc038a
Better diagnostics in log, even though it shouldn't matter anymore
unc0rr
parents:
10254
diff
changeset
|
482 |
begin |
0d20f6fc038a
Better diagnostics in log, even though it shouldn't matter anymore
unc0rr
parents:
10254
diff
changeset
|
483 |
AddFileLog('hiTicks increment (current team is local or gone)'); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
484 |
inc(hiTicks) // we do not recieve a message for this |
10395
0d20f6fc038a
Better diagnostics in log, even though it shouldn't matter anymore
unc0rr
parents:
10254
diff
changeset
|
485 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
486 |
end; |
7407 | 487 |
AddRandomness(CheckSum); |
9672
8663d299ba62
this should prevent sliding when game clock isn't running. sorry unc0rr, not going to bother encapsulating. maybe later. short on time right now/lazy
nemo
parents:
9651
diff
changeset
|
488 |
TurnClockActive:= prevtime <> TurnTimeLeft; |
515 | 489 |
inc(GameTicks) |
4 | 490 |
end; |
491 |
||
3396
e5b3e5f2818e
More portal changes. Allows for a multishoot utility. Hopefully not breaking anything.
nemo
parents:
3390
diff
changeset
|
492 |
//Purpose, to reset all transient attributes toggled by a utility and clean up various gears and effects at end of turn |
1854 | 493 |
//If any of these are set as permanent toggles in the frontend, that needs to be checked and skipped here. |
3396
e5b3e5f2818e
More portal changes. Allows for a multishoot utility. Hopefully not breaking anything.
nemo
parents:
3390
diff
changeset
|
494 |
procedure EndTurnCleanup; |
1865
ebc6dfca60d4
- nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1863
diff
changeset
|
495 |
var i: LongInt; |
3480
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
496 |
t: PGear; |
1849 | 497 |
begin |
2221 | 498 |
SpeechText:= ''; // in case it has not been consumed |
2017 | 499 |
|
1895 | 500 |
if (GameFlags and gfLowGravity) = 0 then |
4623 | 501 |
begin |
5872
454f246fe4c5
uh, that was just so I could look at the flame more closely, wasn't supposed to be checked in
nemo
parents:
5871
diff
changeset
|
502 |
cGravity:= cMaxWindSpeed * 2; |
11887
083c12795632
Show symbols at bottom right while extra damage / low grav. are active
Wuzzy <almikes@aol.com>
parents:
11881
diff
changeset
|
503 |
cGravityf:= 0.00025 * 2; |
083c12795632
Show symbols at bottom right while extra damage / low grav. are active
Wuzzy <almikes@aol.com>
parents:
11881
diff
changeset
|
504 |
cLowGravity:= false |
4623 | 505 |
end; |
1895 | 506 |
|
2017 | 507 |
if (GameFlags and gfVampiric) = 0 then |
508 |
cVampiric:= false; |
|
509 |
||
1849 | 510 |
cDamageModifier:= _1; |
1895 | 511 |
|
512 |
if (GameFlags and gfLaserSight) = 0 then |
|
12306
cdd884397760
Fix sniper rifle disabling laser sight utility after shooting
Wuzzy <almikes@aol.com>
parents:
12210
diff
changeset
|
513 |
begin |
1895 | 514 |
cLaserSighting:= false; |
12306
cdd884397760
Fix sniper rifle disabling laser sight utility after shooting
Wuzzy <almikes@aol.com>
parents:
12210
diff
changeset
|
515 |
cLaserSightingSniper:= false |
cdd884397760
Fix sniper rifle disabling laser sight utility after shooting
Wuzzy <almikes@aol.com>
parents:
12210
diff
changeset
|
516 |
end; |
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
517 |
|
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
518 |
// have to sweep *all* current team hedgehogs since it is theoretically possible if you have enough invulnerabilities and switch turns to make your entire team invulnerable |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
519 |
if (CurrentTeam <> nil) then |
4099 | 520 |
with CurrentTeam^ do |
521 |
for i:= 0 to cMaxHHIndex do |
|
522 |
with Hedgehogs[i] do |
|
523 |
begin |
|
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
524 |
(* |
4099 | 525 |
if (SpeechGear <> nil) then |
526 |
begin |
|
527 |
DeleteVisualGear(SpeechGear); // remove to restore persisting beyond end of turn. Tiy says was too much of a gameplay issue |
|
528 |
SpeechGear:= nil |
|
529 |
end; |
|
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
530 |
*) |
2045
b0588498bc3a
- Fix network (my crappy fault, triggered by nemo's patch)
unc0rr
parents:
2042
diff
changeset
|
531 |
|
4099 | 532 |
if (Gear <> nil) then |
533 |
begin |
|
534 |
if (GameFlags and gfInvulnerable) = 0 then |
|
9685
7d925e82e572
Tweak trophyrace to work better w/ skip (probably, needs testing), drop Invulnerable in favour of effects - heInvulnerable is already in effects,
nemo
parents:
9672
diff
changeset
|
535 |
Gear^.Hedgehog^.Effects[heInvulnerable]:= 0; |
4099 | 536 |
end; |
537 |
end; |
|
3480
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
538 |
t:= GearsList; |
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
539 |
while t <> nil do |
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
540 |
begin |
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
541 |
t^.PortalCounter:= 0; |
4372 | 542 |
if ((GameFlags and gfResetHealth) <> 0) and (t^.Kind = gtHedgehog) and (t^.Health < t^.Hedgehog^.InitialHealth) then |
4101
c5967f360beb
Apply the reset to all hogs on all teams in uGears. Make InitialHealth same type as Health to avoid issues w/ initial health > 255. Update InitialHealth with the king buff.
nemo
parents:
4099
diff
changeset
|
543 |
begin |
12938
b075ad6112c9
Show subtle heal effect for healing hogs in health reset mode
Wuzzy <Wuzzy2@mail.ru>
parents:
12928
diff
changeset
|
544 |
i:= t^.Hedgehog^.InitialHealth - t^.Health; |
4372 | 545 |
t^.Health:= t^.Hedgehog^.InitialHealth; |
12938
b075ad6112c9
Show subtle heal effect for healing hogs in health reset mode
Wuzzy <Wuzzy2@mail.ru>
parents:
12928
diff
changeset
|
546 |
if i > 0 then |
b075ad6112c9
Show subtle heal effect for healing hogs in health reset mode
Wuzzy <Wuzzy2@mail.ru>
parents:
12928
diff
changeset
|
547 |
HHHeal(t^.Hedgehog, i, false, $00FF0040); |
4372 | 548 |
RenderHealth(t^.Hedgehog^); |
4101
c5967f360beb
Apply the reset to all hogs on all teams in uGears. Make InitialHealth same type as Health to avoid issues w/ initial health > 255. Update InitialHealth with the king buff.
nemo
parents:
4099
diff
changeset
|
549 |
end; |
3480
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
550 |
t:= t^.NextGear |
3946
41e06b74c991
Enable resetting of weapons after each turn - useful in combination with a limited weaponset and unlimited attacks
nemo
parents:
3908
diff
changeset
|
551 |
end; |
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset
|
552 |
|
6453
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6380
diff
changeset
|
553 |
if ((GameFlags and gfResetWeps) <> 0) and (not PlacingHogs) then |
4099 | 554 |
ResetWeapons; |
4101
c5967f360beb
Apply the reset to all hogs on all teams in uGears. Make InitialHealth same type as Health to avoid issues w/ initial health > 255. Update InitialHealth with the king buff.
nemo
parents:
4099
diff
changeset
|
555 |
|
4099 | 556 |
if (GameFlags and gfResetHealth) <> 0 then |
4101
c5967f360beb
Apply the reset to all hogs on all teams in uGears. Make InitialHealth same type as Health to avoid issues w/ initial health > 255. Update InitialHealth with the king buff.
nemo
parents:
4099
diff
changeset
|
557 |
for i:= 0 to Pred(TeamsCount) do |
c5967f360beb
Apply the reset to all hogs on all teams in uGears. Make InitialHealth same type as Health to avoid issues w/ initial health > 255. Update InitialHealth with the king buff.
nemo
parents:
4099
diff
changeset
|
558 |
RecountTeamHealth(TeamsArray[i]) |
1849 | 559 |
end; |
2045
b0588498bc3a
- Fix network (my crappy fault, triggered by nemo's patch)
unc0rr
parents:
2042
diff
changeset
|
560 |
|
4385 | 561 |
procedure DrawGears; |
562 |
var Gear: PGear; |
|
563 |
x, y: LongInt; |
|
2802 | 564 |
begin |
4385 | 565 |
Gear:= GearsList; |
566 |
while Gear <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
567 |
begin |
7257
566bdf2f023b
Modified DrawGear so that it doesn't draw the gear when it has message gmRemoveFromList (it was causing havoc when I used HideHog as it could not access the position of the hog)
belphegorr <szabibibi@gmail.com>
parents:
7181
diff
changeset
|
568 |
if (Gear^.State and gstInvisible = 0) and (Gear^.Message and gmRemoveFromList = 0) then |
5348
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset
|
569 |
begin |
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset
|
570 |
x:= hwRound(Gear^.X) + WorldDx; |
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset
|
571 |
y:= hwRound(Gear^.Y) + WorldDy; |
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset
|
572 |
RenderGear(Gear, x, y); |
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset
|
573 |
end; |
4385 | 574 |
Gear:= Gear^.NextGear |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
575 |
end; |
10866 | 576 |
|
577 |
if SpeechHogNumber > 0 then |
|
578 |
DrawHHOrder(); |
|
2802 | 579 |
end; |
580 |
||
12210
442bab755bb4
Render gear timers in front of water
Wuzzy <almikes@aol.com>
parents:
12192
diff
changeset
|
581 |
procedure DrawGearsTimers; |
442bab755bb4
Render gear timers in front of water
Wuzzy <almikes@aol.com>
parents:
12192
diff
changeset
|
582 |
var Gear: PGear; |
442bab755bb4
Render gear timers in front of water
Wuzzy <almikes@aol.com>
parents:
12192
diff
changeset
|
583 |
x, y: LongInt; |
442bab755bb4
Render gear timers in front of water
Wuzzy <almikes@aol.com>
parents:
12192
diff
changeset
|
584 |
begin |
442bab755bb4
Render gear timers in front of water
Wuzzy <almikes@aol.com>
parents:
12192
diff
changeset
|
585 |
Gear:= GearsList; |
442bab755bb4
Render gear timers in front of water
Wuzzy <almikes@aol.com>
parents:
12192
diff
changeset
|
586 |
while Gear <> nil do |
442bab755bb4
Render gear timers in front of water
Wuzzy <almikes@aol.com>
parents:
12192
diff
changeset
|
587 |
begin |
442bab755bb4
Render gear timers in front of water
Wuzzy <almikes@aol.com>
parents:
12192
diff
changeset
|
588 |
x:= hwRound(Gear^.X) + WorldDx; |
442bab755bb4
Render gear timers in front of water
Wuzzy <almikes@aol.com>
parents:
12192
diff
changeset
|
589 |
y:= hwRound(Gear^.Y) + WorldDy; |
442bab755bb4
Render gear timers in front of water
Wuzzy <almikes@aol.com>
parents:
12192
diff
changeset
|
590 |
RenderGearTimer(Gear, x, y); |
442bab755bb4
Render gear timers in front of water
Wuzzy <almikes@aol.com>
parents:
12192
diff
changeset
|
591 |
Gear:= Gear^.NextGear |
442bab755bb4
Render gear timers in front of water
Wuzzy <almikes@aol.com>
parents:
12192
diff
changeset
|
592 |
end; |
442bab755bb4
Render gear timers in front of water
Wuzzy <almikes@aol.com>
parents:
12192
diff
changeset
|
593 |
end; |
442bab755bb4
Render gear timers in front of water
Wuzzy <almikes@aol.com>
parents:
12192
diff
changeset
|
594 |
|
4 | 595 |
procedure FreeGearsList; |
596 |
var t, tt: PGear; |
|
597 |
begin |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
598 |
tt:= GearsList; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
599 |
GearsList:= nil; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
600 |
while tt <> nil do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
601 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
602 |
t:= tt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
603 |
tt:= tt^.NextGear; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
604 |
Dispose(t) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
605 |
end; |
4 | 606 |
end; |
607 |
||
10 | 608 |
procedure AddMiscGears; |
10818
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
609 |
var p,i,j,t,h,unplaced: Longword; |
10494 | 610 |
rx, ry: LongInt; |
7406
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset
|
611 |
rdx, rdy: hwFloat; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
612 |
Gear: PGear; |
4 | 613 |
begin |
498 | 614 |
AddGear(0, 0, gtATStartGame, 0, _0, _0, 2000); |
1435
d4b32ee3caa6
Fix using freed memory (could be the cause of queue error problem and other bugs)
unc0rr
parents:
1434
diff
changeset
|
615 |
|
4830
c5ddc3e6c8a4
Don't waste CPU cycles trying to find a piece of land when there's no free land left
unc0rr
parents:
4826
diff
changeset
|
616 |
i:= 0; |
10236
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
617 |
unplaced:= 0; |
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
618 |
while (i < cLandMines) and (unplaced < 4) do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
619 |
begin |
4148
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
620 |
Gear:= AddGear(0, 0, gtMine, 0, _0, _0, 0); |
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
621 |
FindPlace(Gear, false, 0, LAND_WIDTH); |
10236
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
622 |
|
10510 | 623 |
if Gear = nil then |
10236
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
624 |
inc(unplaced) |
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
625 |
else |
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
626 |
unplaced:= 0; |
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
627 |
|
4830
c5ddc3e6c8a4
Don't waste CPU cycles trying to find a piece of land when there's no free land left
unc0rr
parents:
4826
diff
changeset
|
628 |
inc(i) |
4148
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
629 |
end; |
4830
c5ddc3e6c8a4
Don't waste CPU cycles trying to find a piece of land when there's no free land left
unc0rr
parents:
4826
diff
changeset
|
630 |
|
c5ddc3e6c8a4
Don't waste CPU cycles trying to find a piece of land when there's no free land left
unc0rr
parents:
4826
diff
changeset
|
631 |
i:= 0; |
10236
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
632 |
unplaced:= 0; |
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
633 |
while (i < cExplosives) and (unplaced < 4) do |
4148
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
634 |
begin |
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
635 |
Gear:= AddGear(0, 0, gtExplosives, 0, _0, _0, 0); |
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
636 |
FindPlace(Gear, false, 0, LAND_WIDTH); |
10236
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
637 |
|
10510 | 638 |
if Gear = nil then |
10236
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
639 |
inc(unplaced) |
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
640 |
else |
12447
ac710bb12fbb
Add checkins so that spawning on top of things is possible too
nemo
parents:
12322
diff
changeset
|
641 |
begin |
10236
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
642 |
unplaced:= 0; |
12447
ac710bb12fbb
Add checkins so that spawning on top of things is possible too
nemo
parents:
12322
diff
changeset
|
643 |
AddCI(Gear) |
ac710bb12fbb
Add checkins so that spawning on top of things is possible too
nemo
parents:
12322
diff
changeset
|
644 |
end; |
10236
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
645 |
|
4830
c5ddc3e6c8a4
Don't waste CPU cycles trying to find a piece of land when there's no free land left
unc0rr
parents:
4826
diff
changeset
|
646 |
inc(i) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
647 |
end; |
1895 | 648 |
|
10818
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
649 |
i:= 0; |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
650 |
j:= 0; |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
651 |
p:= 0; // 0 searching, 1 bad position, 2 added. |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
652 |
unplaced:= 0; |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
653 |
if cAirMines > 0 then |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
654 |
Gear:= AddGear(0, 0, gtAirMine, 0, _0, _0, 0); |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
655 |
while (i < cAirMines) and (j < 1000*cAirMines) do |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
656 |
begin |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
657 |
p:= 0; |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
658 |
if hasBorder then |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
659 |
begin |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
660 |
rx:= leftX+GetRandom(rightX-leftX-16)+8; |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
661 |
ry:= topY+GetRandom(LAND_HEIGHT-topY-16)+8 |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
662 |
end |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
663 |
else |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
664 |
begin |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
665 |
rx:= leftX+GetRandom(rightX-leftX+400)-200; |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
666 |
ry:= topY+GetRandom(LAND_HEIGHT-topY+400)-200 |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
667 |
end; |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
668 |
Gear^.X:= int2hwFloat(rx); |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
669 |
Gear^.Y:= int2hwFloat(ry); |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
670 |
if CheckLandValue(rx, ry, $FFFF) and |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
671 |
(TestCollisionYwithGear(Gear,-1) = 0) and |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
672 |
(TestCollisionXwithGear(Gear, 1) = 0) and |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
673 |
(TestCollisionXwithGear(Gear,-1) = 0) and |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
674 |
(TestCollisionYwithGear(Gear, 1) = 0) then |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
675 |
begin |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
676 |
t:= 0; |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
677 |
while (t < TeamsCount) and (p = 0) do |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
678 |
begin |
10820
e86ba0e821a6
Fix bug, undo debug level in server, set air mine number to something non-debug
nemo
parents:
10818
diff
changeset
|
679 |
h:= 0; |
10818
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
680 |
with TeamsArray[t]^ do |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
681 |
while (h < cMaxHHIndex) and (p = 0) do |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
682 |
begin |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
683 |
if (Hedgehogs[h].Gear <> nil) then |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
684 |
begin |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
685 |
rdx:=Gear^.X-Hedgehogs[h].Gear^.X; |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
686 |
rdy:=Gear^.Y-Hedgehogs[h].Gear^.Y; |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
687 |
if (Gear^.Angle < $FFFFFFFF) and |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
688 |
((rdx.Round+rdy.Round < Gear^.Angle) and |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
689 |
(hwRound(hwSqr(rdx) + hwSqr(rdy)) < sqr(Gear^.Angle))) then |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
690 |
begin |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
691 |
// Debug line. Remove later |
10820
e86ba0e821a6
Fix bug, undo debug level in server, set air mine number to something non-debug
nemo
parents:
10818
diff
changeset
|
692 |
// AddFileLog('Too Close to Hog @ (' + inttostr(rx) + ',' + inttostr(ry) + ')'); |
10818
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
693 |
|
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
694 |
p:= 1 |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
695 |
end |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
696 |
end; |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
697 |
inc(h) |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
698 |
end; |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
699 |
inc(t) |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
700 |
end; |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
701 |
if p = 0 then |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
702 |
begin |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
703 |
inc(i); |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
704 |
AddFileLog('Placed Air Mine @ (' + inttostr(rx) + ',' + inttostr(ry) + ')'); |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
705 |
if i < cAirMines then |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
706 |
Gear:= AddGear(0, 0, gtAirMine, 0, _0, _0, 0) |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
707 |
end |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
708 |
end; |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
709 |
inc(j) |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
710 |
end; |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
711 |
if p <> 0 then DeleteGear(Gear); |
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset
|
712 |
|
1895 | 713 |
if (GameFlags and gfLowGravity) <> 0 then |
4623 | 714 |
begin |
3355
dc9e61e67484
cWindSpeed recalculation assumed GetRandom returns a value between 0.0-1.0 while in fact is in the 0.0-0.5 range; Halve cMaxWindSpeed to compensate.
palewolf
parents:
3350
diff
changeset
|
715 |
cGravity:= cMaxWindSpeed; |
11887
083c12795632
Show symbols at bottom right while extra damage / low grav. are active
Wuzzy <almikes@aol.com>
parents:
11881
diff
changeset
|
716 |
cGravityf:= 0.00025; |
083c12795632
Show symbols at bottom right while extra damage / low grav. are active
Wuzzy <almikes@aol.com>
parents:
11881
diff
changeset
|
717 |
cLowGravity:= true |
4623 | 718 |
end; |
1895 | 719 |
|
2017 | 720 |
if (GameFlags and gfVampiric) <> 0 then |
721 |
cVampiric:= true; |
|
722 |
||
1895 | 723 |
Gear:= GearsList; |
724 |
if (GameFlags and gfInvulnerable) <> 0 then |
|
9685
7d925e82e572
Tweak trophyrace to work better w/ skip (probably, needs testing), drop Invulnerable in favour of effects - heInvulnerable is already in effects,
nemo
parents:
9672
diff
changeset
|
725 |
for p:= 0 to Pred(ClansCount) do |
7d925e82e572
Tweak trophyrace to work better w/ skip (probably, needs testing), drop Invulnerable in favour of effects - heInvulnerable is already in effects,
nemo
parents:
9672
diff
changeset
|
726 |
with ClansArray[p]^ do |
7d925e82e572
Tweak trophyrace to work better w/ skip (probably, needs testing), drop Invulnerable in favour of effects - heInvulnerable is already in effects,
nemo
parents:
9672
diff
changeset
|
727 |
for j:= 0 to Pred(TeamsNumber) do |
7d925e82e572
Tweak trophyrace to work better w/ skip (probably, needs testing), drop Invulnerable in favour of effects - heInvulnerable is already in effects,
nemo
parents:
9672
diff
changeset
|
728 |
with Teams[j]^ do |
7d925e82e572
Tweak trophyrace to work better w/ skip (probably, needs testing), drop Invulnerable in favour of effects - heInvulnerable is already in effects,
nemo
parents:
9672
diff
changeset
|
729 |
for i:= 0 to cMaxHHIndex do |
7d925e82e572
Tweak trophyrace to work better w/ skip (probably, needs testing), drop Invulnerable in favour of effects - heInvulnerable is already in effects,
nemo
parents:
9672
diff
changeset
|
730 |
with Hedgehogs[i] do |
7d925e82e572
Tweak trophyrace to work better w/ skip (probably, needs testing), drop Invulnerable in favour of effects - heInvulnerable is already in effects,
nemo
parents:
9672
diff
changeset
|
731 |
Effects[heInvulnerable]:= 1; |
1895 | 732 |
|
733 |
if (GameFlags and gfLaserSight) <> 0 then |
|
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
734 |
cLaserSighting:= true; |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
735 |
|
8030
165aeaaaf445
Call fallers less often. Should hopefully still be about as effective at the intended purpose. Should help loads quite a bit.
nemo
parents:
8011
diff
changeset
|
736 |
for i:= (LAND_WIDTH*LAND_HEIGHT) div 524288+2 downto 0 do |
7575
f415b3e0f3b9
Burn a random number in the override. Make sure cirbuf is reset.
nemo
parents:
7519
diff
changeset
|
737 |
begin |
f415b3e0f3b9
Burn a random number in the override. Make sure cirbuf is reset.
nemo
parents:
7519
diff
changeset
|
738 |
rx:= GetRandom(rightX-leftX)+leftX; |
7406
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset
|
739 |
ry:= GetRandom(LAND_HEIGHT-topY)+topY; |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset
|
740 |
rdx:= _90-(GetRandomf*_360); |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset
|
741 |
rdy:= _90-(GetRandomf*_360); |
13214
9c81e34f1933
gtGenericFaller: Use Tag=1 to allow gtGenericFaller to be displaced randomly. Otherwise it is left alone
Wuzzy <Wuzzy2@mail.ru>
parents:
13171
diff
changeset
|
742 |
Gear:= AddGear(rx, ry, gtGenericFaller, gstInvisible, rdx, rdy, $FFFFFFFF); |
9c81e34f1933
gtGenericFaller: Use Tag=1 to allow gtGenericFaller to be displaced randomly. Otherwise it is left alone
Wuzzy <Wuzzy2@mail.ru>
parents:
13171
diff
changeset
|
743 |
// Tag=1: This allows this generic faller to be displaced randomly by events |
9c81e34f1933
gtGenericFaller: Use Tag=1 to allow gtGenericFaller to be displaced randomly. Otherwise it is left alone
Wuzzy <Wuzzy2@mail.ru>
parents:
13171
diff
changeset
|
744 |
Gear^.Tag:= 1; |
7406
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset
|
745 |
end; |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset
|
746 |
|
7477
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7426
diff
changeset
|
747 |
snowRight:= max(LAND_WIDTH,4096)+512; |
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7426
diff
changeset
|
748 |
snowLeft:= -(snowRight-LAND_WIDTH); |
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7426
diff
changeset
|
749 |
|
9768
08799c901a42
Add rubber utility. Graphics are still incomplete. Also flag snow/ice in theme config.
nemo
parents:
9764
diff
changeset
|
750 |
if (not hasBorder) and cSnow then |
7721 | 751 |
for i:= vobCount * Longword(max(LAND_WIDTH,4096)) div 2048 downto 1 do |
9951
b776cd642d0b
pick random x/y prior to addgear (as generic faller does) to avoid random numbers picked out of order
nemo
parents:
9818
diff
changeset
|
752 |
begin |
b776cd642d0b
pick random x/y prior to addgear (as generic faller does) to avoid random numbers picked out of order
nemo
parents:
9818
diff
changeset
|
753 |
rx:=GetRandom(snowRight - snowLeft); |
b776cd642d0b
pick random x/y prior to addgear (as generic faller does) to avoid random numbers picked out of order
nemo
parents:
9818
diff
changeset
|
754 |
ry:=GetRandom(750); |
10494 | 755 |
AddGear(rx + snowLeft, LongInt(LAND_HEIGHT) + ry - 1300, gtFlake, 0, _0, _0, 0) |
9951
b776cd642d0b
pick random x/y prior to addgear (as generic faller does) to avoid random numbers picked out of order
nemo
parents:
9818
diff
changeset
|
756 |
end |
4 | 757 |
end; |
758 |
||
11702
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
759 |
// sort clans horizontally (bubble-sort, because why not) |
11703
607e2e43acf0
cleaning up team divide mode code from last night a little
sheepluva
parents:
11702
diff
changeset
|
760 |
procedure SortHHsByClan(); |
11702
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
761 |
var n, newn, i, j, k, p: LongInt; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
762 |
ar, clar: array[0..Pred(cMaxHHs)] of PHedgehog; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
763 |
Count, clCount: Longword; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
764 |
tmpX, tmpY: hwFloat; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
765 |
hh1, hh2: PHedgehog; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
766 |
begin |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
767 |
Count:= 0; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
768 |
// add hedgehogs to the array in clan order |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
769 |
for p:= 0 to (ClansCount - 1) do |
11734 | 770 |
with SpawnClansArray[p]^ do |
11702
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
771 |
begin |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
772 |
// count hogs in this clan |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
773 |
clCount:= 0; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
774 |
for j:= 0 to Pred(TeamsNumber) do |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
775 |
with Teams[j]^ do |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
776 |
for i:= 0 to cMaxHHIndex do |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
777 |
if Hedgehogs[i].Gear <> nil then |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
778 |
begin |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
779 |
clar[clCount]:= @Hedgehogs[i]; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
780 |
inc(clCount); |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
781 |
end; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
782 |
|
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
783 |
// shuffle all hogs of this clan |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
784 |
for i:= 0 to clCount - 1 do |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
785 |
begin |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
786 |
j:= GetRandom(clCount); |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
787 |
k:= GetRandom(clCount); |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
788 |
if clar[j] <> clar[k] then |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
789 |
begin |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
790 |
hh1:= clar[j]; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
791 |
clar[j]:= clar[k]; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
792 |
clar[k]:= hh1; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
793 |
end; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
794 |
end; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
795 |
|
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
796 |
// add clan's hog to sorting array |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
797 |
for i:= 0 to clCount - 1 do |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
798 |
begin |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
799 |
ar[Count]:= clar[i]; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
800 |
inc(Count); |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
801 |
end; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
802 |
end; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
803 |
|
11703
607e2e43acf0
cleaning up team divide mode code from last night a little
sheepluva
parents:
11702
diff
changeset
|
804 |
|
607e2e43acf0
cleaning up team divide mode code from last night a little
sheepluva
parents:
11702
diff
changeset
|
805 |
// bubble-sort hog array |
11702
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
806 |
n:= Count - 1; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
807 |
|
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
808 |
repeat |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
809 |
newn:= 0; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
810 |
for i:= 1 to n do |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
811 |
begin |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
812 |
hh1:= ar[i-1]; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
813 |
hh2:= ar[i]; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
814 |
if hwRound(hh1^.Gear^.X) > hwRound(hh2^.Gear^.X) then |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
815 |
begin |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
816 |
tmpX:= hh1^.Gear^.X; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
817 |
tmpY:= hh1^.Gear^.Y; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
818 |
hh1^.Gear^.X:= hh2^.Gear^.X; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
819 |
hh1^.Gear^.Y:= hh2^.Gear^.Y; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
820 |
hh2^.Gear^.X:= tmpX; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
821 |
hh2^.Gear^.Y:= tmpY; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
822 |
newn:= i; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
823 |
end; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
824 |
end; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
825 |
n:= newn; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
826 |
until n = 0; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
827 |
|
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
828 |
end; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
829 |
|
4 | 830 |
procedure AssignHHCoords; |
955 | 831 |
var i, t, p, j: LongInt; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
832 |
ar: array[0..Pred(cMaxHHs)] of PHedgehog; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
833 |
Count: Longword; |
11896
cb36d6df3814
reenable divided-mode spawning hack^Wtweak, that was accidently removed in 34ede05e4d4f
sheepluva
parents:
11895
diff
changeset
|
834 |
divide, sectionDivide: boolean; |
4 | 835 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
836 |
if (GameFlags and gfPlaceHog) <> 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
837 |
PlacingHogs:= true; |
11703
607e2e43acf0
cleaning up team divide mode code from last night a little
sheepluva
parents:
11702
diff
changeset
|
838 |
|
607e2e43acf0
cleaning up team divide mode code from last night a little
sheepluva
parents:
11702
diff
changeset
|
839 |
divide:= ((GameFlags and gfDivideTeams) <> 0); |
607e2e43acf0
cleaning up team divide mode code from last night a little
sheepluva
parents:
11702
diff
changeset
|
840 |
|
11896
cb36d6df3814
reenable divided-mode spawning hack^Wtweak, that was accidently removed in 34ede05e4d4f
sheepluva
parents:
11895
diff
changeset
|
841 |
(* sectionDivide will determine the mode of hog distribution |
cb36d6df3814
reenable divided-mode spawning hack^Wtweak, that was accidently removed in 34ede05e4d4f
sheepluva
parents:
11895
diff
changeset
|
842 |
* |
cb36d6df3814
reenable divided-mode spawning hack^Wtweak, that was accidently removed in 34ede05e4d4f
sheepluva
parents:
11895
diff
changeset
|
843 |
* On generated maps or maps not designed with divided mode in mind, |
cb36d6df3814
reenable divided-mode spawning hack^Wtweak, that was accidently removed in 34ede05e4d4f
sheepluva
parents:
11895
diff
changeset
|
844 |
* using spawning sections can be problematic, because some sections may |
cb36d6df3814
reenable divided-mode spawning hack^Wtweak, that was accidently removed in 34ede05e4d4f
sheepluva
parents:
11895
diff
changeset
|
845 |
* contain too little land surface for sensible spawning. |
cb36d6df3814
reenable divided-mode spawning hack^Wtweak, that was accidently removed in 34ede05e4d4f
sheepluva
parents:
11895
diff
changeset
|
846 |
* |
cb36d6df3814
reenable divided-mode spawning hack^Wtweak, that was accidently removed in 34ede05e4d4f
sheepluva
parents:
11895
diff
changeset
|
847 |
* if sectionDivide is true, the map will be sliced into equal-width sections |
cb36d6df3814
reenable divided-mode spawning hack^Wtweak, that was accidently removed in 34ede05e4d4f
sheepluva
parents:
11895
diff
changeset
|
848 |
* and one team spawned in each |
cb36d6df3814
reenable divided-mode spawning hack^Wtweak, that was accidently removed in 34ede05e4d4f
sheepluva
parents:
11895
diff
changeset
|
849 |
* if false, the hogs will be spawned normally and sorted by teams after |
cb36d6df3814
reenable divided-mode spawning hack^Wtweak, that was accidently removed in 34ede05e4d4f
sheepluva
parents:
11895
diff
changeset
|
850 |
* |
cb36d6df3814
reenable divided-mode spawning hack^Wtweak, that was accidently removed in 34ede05e4d4f
sheepluva
parents:
11895
diff
changeset
|
851 |
*) |
cb36d6df3814
reenable divided-mode spawning hack^Wtweak, that was accidently removed in 34ede05e4d4f
sheepluva
parents:
11895
diff
changeset
|
852 |
|
cb36d6df3814
reenable divided-mode spawning hack^Wtweak, that was accidently removed in 34ede05e4d4f
sheepluva
parents:
11895
diff
changeset
|
853 |
// TODO: there might be a smarter way to decide if dividing clans into equal-width map sections makes sense |
cb36d6df3814
reenable divided-mode spawning hack^Wtweak, that was accidently removed in 34ede05e4d4f
sheepluva
parents:
11895
diff
changeset
|
854 |
// e.g. by checking if there is enough spawn area in each section |
cb36d6df3814
reenable divided-mode spawning hack^Wtweak, that was accidently removed in 34ede05e4d4f
sheepluva
parents:
11895
diff
changeset
|
855 |
sectionDivide:= divide and ((cMapGen = mgForts) or (ClansCount = 2)); |
cb36d6df3814
reenable divided-mode spawning hack^Wtweak, that was accidently removed in 34ede05e4d4f
sheepluva
parents:
11895
diff
changeset
|
856 |
|
cb36d6df3814
reenable divided-mode spawning hack^Wtweak, that was accidently removed in 34ede05e4d4f
sheepluva
parents:
11895
diff
changeset
|
857 |
// divide the map into equal-width sections and put each clan in one of them |
cb36d6df3814
reenable divided-mode spawning hack^Wtweak, that was accidently removed in 34ede05e4d4f
sheepluva
parents:
11895
diff
changeset
|
858 |
if sectionDivide then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
859 |
begin |
11705 | 860 |
t:= leftX; |
11700
ea1097d7bd27
"divided teams" modifier will now work with more than 2 teams!
sheepluva
parents:
11532
diff
changeset
|
861 |
for p:= 0 to (ClansCount - 1) do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
862 |
begin |
11734 | 863 |
with SpawnClansArray[p]^ do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
864 |
for j:= 0 to Pred(TeamsNumber) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
865 |
with Teams[j]^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
866 |
for i:= 0 to cMaxHHIndex do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
867 |
with Hedgehogs[i] do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
868 |
if (Gear <> nil) and (Gear^.X.QWordValue = 0) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
869 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
870 |
if PlacingHogs then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
871 |
Unplaced:= true |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
872 |
else |
11705 | 873 |
FindPlace(Gear, false, t, t + playWidth div ClansCount, true);// could make Gear == nil; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
874 |
if Gear <> nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
875 |
begin |
12450 | 876 |
//AddCI(Gear); uncomment if new hogs should be able to spawn on top of old ones. |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
877 |
Gear^.Pos:= GetRandom(49); |
11700
ea1097d7bd27
"divided teams" modifier will now work with more than 2 teams!
sheepluva
parents:
11532
diff
changeset
|
878 |
// unless the world is wrapping, make outter teams face to map center |
ea1097d7bd27
"divided teams" modifier will now work with more than 2 teams!
sheepluva
parents:
11532
diff
changeset
|
879 |
if (WorldEdge <> weWrap) and ((p = 0) or (p = ClansCount - 1)) then |
ea1097d7bd27
"divided teams" modifier will now work with more than 2 teams!
sheepluva
parents:
11532
diff
changeset
|
880 |
Gear^.dX.isNegative:= (p <> 0) |
ea1097d7bd27
"divided teams" modifier will now work with more than 2 teams!
sheepluva
parents:
11532
diff
changeset
|
881 |
else |
ea1097d7bd27
"divided teams" modifier will now work with more than 2 teams!
sheepluva
parents:
11532
diff
changeset
|
882 |
Gear^.dX.isNegative:= (GetRandom(2) = 1); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
883 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
884 |
end; |
11705 | 885 |
inc(t, playWidth div ClansCount); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
886 |
end |
11477
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11469
diff
changeset
|
887 |
end |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11469
diff
changeset
|
888 |
else // mix hedgehogs |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
889 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
890 |
Count:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
891 |
for p:= 0 to Pred(TeamsCount) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
892 |
with TeamsArray[p]^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
893 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
894 |
for i:= 0 to cMaxHHIndex do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
895 |
with Hedgehogs[i] do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
896 |
if (Gear <> nil) and (Gear^.X.QWordValue = 0) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
897 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
898 |
ar[Count]:= @Hedgehogs[i]; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
899 |
inc(Count) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
900 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
901 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
902 |
while (Count > 0) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
903 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
904 |
i:= GetRandom(Count); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
905 |
if PlacingHogs then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
906 |
ar[i]^.Unplaced:= true |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
907 |
else |
11805
42c11b73f68e
<unC0Rr> might be somewhere width used instead of rightx
sheepluva
parents:
11751
diff
changeset
|
908 |
FindPlace(ar[i]^.Gear, false, leftX, rightX, true); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
909 |
if ar[i]^.Gear <> nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
910 |
begin |
12450 | 911 |
//AddCI(ar[i]^.Gear); uncomment if new hogs should be able to spawn on top of old ones |
11705 | 912 |
ar[i]^.Gear^.dX.isNegative:= hwRound(ar[i]^.Gear^.X) > leftX + playWidth div 2; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
913 |
ar[i]^.Gear^.Pos:= GetRandom(19) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
914 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
915 |
ar[i]:= ar[Count - 1]; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
916 |
dec(Count) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
917 |
end |
11477
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11469
diff
changeset
|
918 |
end; |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11469
diff
changeset
|
919 |
for p:= 0 to Pred(TeamsCount) do |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11469
diff
changeset
|
920 |
with TeamsArray[p]^ do |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11469
diff
changeset
|
921 |
for i:= 0 to cMaxHHIndex do |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11469
diff
changeset
|
922 |
with Hedgehogs[i] do |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11469
diff
changeset
|
923 |
if (Gear <> nil) and (Gear^.State and gsttmpFlag <> 0) then |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11469
diff
changeset
|
924 |
begin |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11469
diff
changeset
|
925 |
DrawExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50); |
11478
8c95d5a4366c
Tweak the hole carving to become less agressive about spacing if random points keep failing.
nemo
parents:
11477
diff
changeset
|
926 |
AddFileLog('Carved a hole for hog at coordinates (' + inttostr(hwRound(Gear^.X)) + ',' + inttostr(hwRound(Gear^.Y)) + ')') |
8c95d5a4366c
Tweak the hole carving to become less agressive about spacing if random points keep failing.
nemo
parents:
11477
diff
changeset
|
927 |
end; |
8c95d5a4366c
Tweak the hole carving to become less agressive about spacing if random points keep failing.
nemo
parents:
11477
diff
changeset
|
928 |
// place flowers after in case holes overlap (we shrink search distance if we are failing to place) |
8c95d5a4366c
Tweak the hole carving to become less agressive about spacing if random points keep failing.
nemo
parents:
11477
diff
changeset
|
929 |
for p:= 0 to Pred(TeamsCount) do |
8c95d5a4366c
Tweak the hole carving to become less agressive about spacing if random points keep failing.
nemo
parents:
11477
diff
changeset
|
930 |
with TeamsArray[p]^ do |
8c95d5a4366c
Tweak the hole carving to become less agressive about spacing if random points keep failing.
nemo
parents:
11477
diff
changeset
|
931 |
for i:= 0 to cMaxHHIndex do |
8c95d5a4366c
Tweak the hole carving to become less agressive about spacing if random points keep failing.
nemo
parents:
11477
diff
changeset
|
932 |
with Hedgehogs[i] do |
8c95d5a4366c
Tweak the hole carving to become less agressive about spacing if random points keep failing.
nemo
parents:
11477
diff
changeset
|
933 |
if (Gear <> nil) and (Gear^.State and gsttmpFlag <> 0) then |
8c95d5a4366c
Tweak the hole carving to become less agressive about spacing if random points keep failing.
nemo
parents:
11477
diff
changeset
|
934 |
begin |
11477
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11469
diff
changeset
|
935 |
ForcePlaceOnLand(hwRound(Gear^.X) - SpritesData[sprTargetBee].Width div 2, |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11469
diff
changeset
|
936 |
hwRound(Gear^.Y) - SpritesData[sprTargetBee].Height div 2, |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11469
diff
changeset
|
937 |
sprTargetBee, 0, lfBasic, $FFFFFFFF, false, false, false); |
e425a6eb9da3
Force locations for hogs if even TryHard fails on initial spawn.
nemo
parents:
11469
diff
changeset
|
938 |
Gear^.Y:= int2hwFloat(hwRound(Gear^.Y) - 16 - Gear^.Radius); |
12447
ac710bb12fbb
Add checkins so that spawning on top of things is possible too
nemo
parents:
12322
diff
changeset
|
939 |
AddCI(Gear); |
11503 | 940 |
Gear^.State:= Gear^.State and (not gsttmpFlag); |
11750 | 941 |
AddFileLog('Placed flower for hog at coordinates (' + inttostr(hwRound(Gear^.X)) + ',' + inttostr(hwRound(Gear^.Y)) + ')') |
11702
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
942 |
end; |
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
943 |
|
08cbd57ffb1a
divided teams: better horizontal clan distribution
sheepluva
parents:
11700
diff
changeset
|
944 |
|
11703
607e2e43acf0
cleaning up team divide mode code from last night a little
sheepluva
parents:
11702
diff
changeset
|
945 |
// divided teams: sort the hedgehogs from left to right by clan and shuffle clan members |
11896
cb36d6df3814
reenable divided-mode spawning hack^Wtweak, that was accidently removed in 34ede05e4d4f
sheepluva
parents:
11895
diff
changeset
|
946 |
if divide and (not sectionDivide) then |
11703
607e2e43acf0
cleaning up team divide mode code from last night a little
sheepluva
parents:
11702
diff
changeset
|
947 |
SortHHsByClan(); |
4 | 948 |
end; |
949 |
||
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
950 |
|
1433 | 951 |
{procedure AmmoFlameWork(Ammo: PGear); |
79 | 952 |
var t: PGear; |
953 |
begin |
|
954 |
t:= GearsList; |
|
955 |
while t <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
956 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
957 |
if (t^.Kind = gtHedgehog) and (t^.Y < Ammo^.Y) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
958 |
if not (hwSqr(Ammo^.X - t^.X) + hwSqr(Ammo^.Y - t^.Y - int2hwFloat(cHHRadius)) * 2 > _2) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
959 |
begin |
2017 | 960 |
ApplyDamage(t, 5); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
961 |
t^.dX:= t^.dX + (t^.X - Ammo^.X) * _0_02; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
962 |
t^.dY:= - _0_25; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
963 |
t^.Active:= true; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
964 |
DeleteCI(t); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
965 |
FollowGear:= t |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
966 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
967 |
t:= t^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
968 |
end; |
1433 | 969 |
end;} |
79 | 970 |
|
16 | 971 |
|
7337
c224cd2d32f3
Allow script to set number of ammo in a crate. untested.
nemo
parents:
7335
diff
changeset
|
972 |
function SpawnCustomCrateAt(x, y: LongInt; crate: TCrateType; content, cnt: Longword): PGear; |
3730 | 973 |
begin |
3734 | 974 |
FollowGear := AddGear(x, y, gtCase, 0, _0, _0, 0); |
975 |
cCaseFactor := 0; |
|
976 |
||
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
977 |
if (crate <> HealthCrate) and (content > ord(High(TAmmoType))) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
978 |
content := ord(High(TAmmoType)); |
3734 | 979 |
|
7337
c224cd2d32f3
Allow script to set number of ammo in a crate. untested.
nemo
parents:
7335
diff
changeset
|
980 |
FollowGear^.Power:= cnt; |
c224cd2d32f3
Allow script to set number of ammo in a crate. untested.
nemo
parents:
7335
diff
changeset
|
981 |
|
3734 | 982 |
case crate of |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
983 |
HealthCrate: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
984 |
begin |
3734 | 985 |
FollowGear^.Pos := posCaseHealth; |
10506 | 986 |
// health crate is smaller than the other crates |
987 |
FollowGear^.Radius := cCaseHealthRadius; |
|
5313
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
988 |
FollowGear^.Health := content; |
3734 | 989 |
AddCaption(GetEventString(eidNewHealthPack), cWhiteColor, capgrpAmmoInfo); |
990 |
end; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
991 |
AmmoCrate: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
992 |
begin |
3734 | 993 |
FollowGear^.Pos := posCaseAmmo; |
4240
4e81670e52aa
er. and cast to TAmmoType, which burp's routine still requires :)
nemo
parents:
4239
diff
changeset
|
994 |
FollowGear^.AmmoType := TAmmoType(content); |
3734 | 995 |
AddCaption(GetEventString(eidNewAmmoPack), cWhiteColor, capgrpAmmoInfo); |
996 |
end; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
997 |
UtilityCrate: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
998 |
begin |
3734 | 999 |
FollowGear^.Pos := posCaseUtility; |
4240
4e81670e52aa
er. and cast to TAmmoType, which burp's routine still requires :)
nemo
parents:
4239
diff
changeset
|
1000 |
FollowGear^.AmmoType := TAmmoType(content); |
3734 | 1001 |
AddCaption(GetEventString(eidNewUtilityPack), cWhiteColor, capgrpAmmoInfo); |
1002 |
end; |
|
1003 |
end; |
|
3750
3aa85b5f3318
SpawnCustomCrateAt: spawn crate at random position for x=y=0, also let it return the gear, and luabindings the gear uid
burp
parents:
3749
diff
changeset
|
1004 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1005 |
if ( (x = 0) and (y = 0) ) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1006 |
FindPlace(FollowGear, true, 0, LAND_WIDTH); |
3750
3aa85b5f3318
SpawnCustomCrateAt: spawn crate at random position for x=y=0, also let it return the gear, and luabindings the gear uid
burp
parents:
3749
diff
changeset
|
1007 |
|
3aa85b5f3318
SpawnCustomCrateAt: spawn crate at random position for x=y=0, also let it return the gear, and luabindings the gear uid
burp
parents:
3749
diff
changeset
|
1008 |
SpawnCustomCrateAt := FollowGear; |
3730 | 1009 |
end; |
1010 |
||
5343 | 1011 |
function SpawnFakeCrateAt(x, y: LongInt; crate: TCrateType; explode: boolean; poison: boolean): PGear; |
5313
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1012 |
begin |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1013 |
FollowGear := AddGear(x, y, gtCase, 0, _0, _0, 0); |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1014 |
cCaseFactor := 0; |
5343 | 1015 |
FollowGear^.Pos := posCaseDummy; |
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset
|
1016 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1017 |
if explode then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1018 |
FollowGear^.Pos := FollowGear^.Pos + posCaseExplode; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1019 |
if poison then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1020 |
FollowGear^.Pos := FollowGear^.Pos + posCasePoison; |
5313
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1021 |
|
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1022 |
case crate of |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1023 |
HealthCrate: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1024 |
begin |
5313
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1025 |
FollowGear^.Pos := FollowGear^.Pos + posCaseHealth; |
10506 | 1026 |
// health crate is smaller than the other crates |
1027 |
FollowGear^.Radius := cCaseHealthRadius; |
|
5313
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1028 |
AddCaption(GetEventString(eidNewHealthPack), cWhiteColor, capgrpAmmoInfo); |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1029 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1030 |
AmmoCrate: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1031 |
begin |
5313
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1032 |
FollowGear^.Pos := FollowGear^.Pos + posCaseAmmo; |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1033 |
AddCaption(GetEventString(eidNewAmmoPack), cWhiteColor, capgrpAmmoInfo); |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1034 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1035 |
UtilityCrate: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1036 |
begin |
5313
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1037 |
FollowGear^.Pos := FollowGear^.Pos + posCaseUtility; |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1038 |
AddCaption(GetEventString(eidNewUtilityPack), cWhiteColor, capgrpAmmoInfo); |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1039 |
end; |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1040 |
end; |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1041 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1042 |
if ( (x = 0) and (y = 0) ) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1043 |
FindPlace(FollowGear, true, 0, LAND_WIDTH); |
5313
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1044 |
|
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1045 |
SpawnFakeCrateAt := FollowGear; |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1046 |
end; |
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5296
diff
changeset
|
1047 |
|
12918
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
1048 |
procedure StartSuddenDeath(); |
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
1049 |
begin |
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
1050 |
if SuddenDeath then |
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
1051 |
exit; |
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
1052 |
|
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
1053 |
SuddenDeath:= true; |
12920
21827fc9ca98
Fix timebox being usable in SD w/ damage=0
Wuzzy <Wuzzy2@mail.ru>
parents:
12918
diff
changeset
|
1054 |
SuddenDeathActive:= true; |
21827fc9ca98
Fix timebox being usable in SD w/ damage=0
Wuzzy <Wuzzy2@mail.ru>
parents:
12918
diff
changeset
|
1055 |
|
21827fc9ca98
Fix timebox being usable in SD w/ damage=0
Wuzzy <Wuzzy2@mail.ru>
parents:
12918
diff
changeset
|
1056 |
// Special effects (only w/ health decrease) |
12918
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
1057 |
if cHealthDecrease <> 0 then |
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
1058 |
begin |
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
1059 |
SuddenDeathDmg:= true; |
12920
21827fc9ca98
Fix timebox being usable in SD w/ damage=0
Wuzzy <Wuzzy2@mail.ru>
parents:
12918
diff
changeset
|
1060 |
// White screen flash |
12918
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
1061 |
ScreenFade:= sfFromWhite; |
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
1062 |
ScreenFadeValue:= sfMax; |
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
1063 |
ScreenFadeSpeed:= 1; |
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
1064 |
|
12920
21827fc9ca98
Fix timebox being usable in SD w/ damage=0
Wuzzy <Wuzzy2@mail.ru>
parents:
12918
diff
changeset
|
1065 |
// Clouds, flakes, sky tint |
12918
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
1066 |
ChangeToSDClouds; |
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
1067 |
ChangeToSDFlakes; |
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
1068 |
SetSkyColor(SDSkyColor.r * (SDTint.r/255) / 255, SDSkyColor.g * (SDTint.g/255) / 255, SDSkyColor.b * (SDTint.b/255) / 255); |
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
1069 |
end; |
12920
21827fc9ca98
Fix timebox being usable in SD w/ damage=0
Wuzzy <Wuzzy2@mail.ru>
parents:
12918
diff
changeset
|
1070 |
|
21827fc9ca98
Fix timebox being usable in SD w/ damage=0
Wuzzy <Wuzzy2@mail.ru>
parents:
12918
diff
changeset
|
1071 |
// Disable tardis |
21827fc9ca98
Fix timebox being usable in SD w/ damage=0
Wuzzy <Wuzzy2@mail.ru>
parents:
12918
diff
changeset
|
1072 |
Ammoz[amTardis].SkipTurns:= 9999; |
21827fc9ca98
Fix timebox being usable in SD w/ damage=0
Wuzzy <Wuzzy2@mail.ru>
parents:
12918
diff
changeset
|
1073 |
Ammoz[amTardis].Probability:= 0; |
21827fc9ca98
Fix timebox being usable in SD w/ damage=0
Wuzzy <Wuzzy2@mail.ru>
parents:
12918
diff
changeset
|
1074 |
|
12918
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
1075 |
AddCaption(trmsg[sidSuddenDeath], cWhiteColor, capgrpGameState); |
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
1076 |
ScriptCall('onSuddenDeath'); |
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
1077 |
playSound(sndSuddenDeath); |
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
1078 |
StopMusic; |
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
1079 |
if SDMusicFN <> '' then |
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
1080 |
PlayMusic |
6deb29364723
Refactor Sudden Death starting into own function
Wuzzy <Wuzzy2@mail.ru>
parents:
12916
diff
changeset
|
1081 |
end; |
2726 | 1082 |
|
2790 | 1083 |
function GearByUID(uid : Longword) : PGear; |
1084 |
var gear: PGear; |
|
1085 |
begin |
|
1086 |
GearByUID:= nil; |
|
4780
8571151411b3
add a couple of variables to speed up UID lookups. Based on the assumption new visual gears and gears will tend to be at the end of the list. Set them on successful lookup or script gear creation, clear on delete. Oh also pick up a couple of TrevInc's translation changes
nemo
parents:
4748
diff
changeset
|
1087 |
if uid = 0 then exit; |
8571151411b3
add a couple of variables to speed up UID lookups. Based on the assumption new visual gears and gears will tend to be at the end of the list. Set them on successful lookup or script gear creation, clear on delete. Oh also pick up a couple of TrevInc's translation changes
nemo
parents:
4748
diff
changeset
|
1088 |
if (lastGearByUID <> nil) and (lastGearByUID^.uid = uid) then |
8571151411b3
add a couple of variables to speed up UID lookups. Based on the assumption new visual gears and gears will tend to be at the end of the list. Set them on successful lookup or script gear creation, clear on delete. Oh also pick up a couple of TrevInc's translation changes
nemo
parents:
4748
diff
changeset
|
1089 |
begin |
8571151411b3
add a couple of variables to speed up UID lookups. Based on the assumption new visual gears and gears will tend to be at the end of the list. Set them on successful lookup or script gear creation, clear on delete. Oh also pick up a couple of TrevInc's translation changes
nemo
parents:
4748
diff
changeset
|
1090 |
GearByUID:= lastGearByUID; |
8571151411b3
add a couple of variables to speed up UID lookups. Based on the assumption new visual gears and gears will tend to be at the end of the list. Set them on successful lookup or script gear creation, clear on delete. Oh also pick up a couple of TrevInc's translation changes
nemo
parents:
4748
diff
changeset
|
1091 |
exit |
8571151411b3
add a couple of variables to speed up UID lookups. Based on the assumption new visual gears and gears will tend to be at the end of the list. Set them on successful lookup or script gear creation, clear on delete. Oh also pick up a couple of TrevInc's translation changes
nemo
parents:
4748
diff
changeset
|
1092 |
end; |
2790 | 1093 |
gear:= GearsList; |
1094 |
while gear <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1095 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1096 |
if gear^.uid = uid then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1097 |
begin |
4780
8571151411b3
add a couple of variables to speed up UID lookups. Based on the assumption new visual gears and gears will tend to be at the end of the list. Set them on successful lookup or script gear creation, clear on delete. Oh also pick up a couple of TrevInc's translation changes
nemo
parents:
4748
diff
changeset
|
1098 |
lastGearByUID:= gear; |
8571151411b3
add a couple of variables to speed up UID lookups. Based on the assumption new visual gears and gears will tend to be at the end of the list. Set them on successful lookup or script gear creation, clear on delete. Oh also pick up a couple of TrevInc's translation changes
nemo
parents:
4748
diff
changeset
|
1099 |
GearByUID:= gear; |
8571151411b3
add a couple of variables to speed up UID lookups. Based on the assumption new visual gears and gears will tend to be at the end of the list. Set them on successful lookup or script gear creation, clear on delete. Oh also pick up a couple of TrevInc's translation changes
nemo
parents:
4748
diff
changeset
|
1100 |
exit |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1101 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1102 |
gear:= gear^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1103 |
end |
2790 | 1104 |
end; |
1105 |
||
11916
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
1106 |
function IsClockRunning() : boolean; |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
1107 |
begin |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
1108 |
IsClockRunning := |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
1109 |
(CurrentHedgehog^.Gear <> nil) |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
1110 |
and (((CurrentHedgehog^.Gear^.State and gstAttacking) = 0) |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
1111 |
or (Ammoz[CurrentHedgehog^.CurAmmoType].Ammo.Propz and ammoprop_DoesntStopTimerWhileAttacking <> 0) |
11918
9da78300c5d0
Fix sniper rifle making timer gray all the time
Wuzzy <almikes@aol.com>
parents:
11916
diff
changeset
|
1112 |
or ((GameFlags and gfInfAttack) <> 0) and (Ammoz[CurrentHedgehog^.CurAmmoType].Ammo.Propz and ammoprop_DoesntStopTimerWhileAttackingInInfAttackMode <> 0) |
9da78300c5d0
Fix sniper rifle making timer gray all the time
Wuzzy <almikes@aol.com>
parents:
11916
diff
changeset
|
1113 |
or (CurrentHedgehog^.CurAmmoType = amSniperRifle)) |
11916
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
1114 |
and (not(isInMultiShoot and ((Ammoz[CurrentHedgehog^.CurAmmoType].Ammo.Propz and ammoprop_DoesntStopTimerInMultiShoot) <> 0))); |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
1115 |
end; |
38fa4583e7f3
Make timer gray while the time is not running or while it is paused
Wuzzy <almikes@aol.com>
parents:
11915
diff
changeset
|
1116 |
|
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1117 |
|
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1118 |
procedure chSkip(var s: shortstring); |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1119 |
begin |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1120 |
s:= s; // avoid compiler hint |
7805 | 1121 |
if not isExternalSource then |
7068 | 1122 |
SendIPC(_S','); |
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1123 |
uStats.Skipped; |
13171
9f80c08cdae9
Lua API: Add onSkipTurn callback, called when hog skips
Wuzzy <Wuzzy2@mail.ru>
parents:
13096
diff
changeset
|
1124 |
skipFlag:= true; |
9f80c08cdae9
Lua API: Add onSkipTurn callback, called when hog skips
Wuzzy <Wuzzy2@mail.ru>
parents:
13096
diff
changeset
|
1125 |
ScriptCall('onSkipTurn'); |
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1126 |
end; |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1127 |
|
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1128 |
procedure chHogSay(var s: shortstring); |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1129 |
var Gear: PVisualGear; |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1130 |
text: shortstring; |
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1131 |
hh: PHedgehog; |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1132 |
i, x, t, h: byte; |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1133 |
c, j: LongInt; |
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1134 |
begin |
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1135 |
hh:= nil; |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1136 |
i:= 0; |
4469 | 1137 |
t:= 0; |
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1138 |
x:= byte(s[1]); // speech type |
4469 | 1139 |
if x < 4 then |
1140 |
begin |
|
1141 |
t:= byte(s[2]); // team |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1142 |
if Length(s) > 2 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1143 |
h:= byte(s[3]) // target hog |
10490 | 1144 |
else |
1145 |
h:= 0 |
|
4469 | 1146 |
end; |
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1147 |
// allow targetting a hog by specifying a number as the first portion of the text |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1148 |
if (x < 4) and (h > byte('0')) and (h < byte('9')) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1149 |
i:= h - 48; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1150 |
if i <> 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1151 |
text:= copy(s, 4, Length(s) - 1) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1152 |
else if x < 4 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1153 |
text:= copy(s, 3, Length(s) - 1) |
4468 | 1154 |
else text:= copy(s, 2, Length(s) - 1); |
1155 |
||
9818 | 1156 |
if text = '' then text:= '...'; |
1157 |
||
4470
d2b8d2fc51a9
disable say, just don't do anything. trying to avoid spew on spectator join
nemo
parents:
4469
diff
changeset
|
1158 |
(* |
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1159 |
if CheckNoTeamOrHH then |
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1160 |
begin |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1161 |
ParseCommand('say ' + text, true); |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1162 |
exit |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1163 |
end; |
4470
d2b8d2fc51a9
disable say, just don't do anything. trying to avoid spew on spectator join
nemo
parents:
4469
diff
changeset
|
1164 |
*) |
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1165 |
|
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1166 |
if (x < 4) and (TeamsArray[t] <> nil) then |
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1167 |
begin |
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1168 |
// if team matches current hedgehog team, default to current hedgehog |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1169 |
if (i = 0) and (CurrentHedgehog <> nil) and (CurrentHedgehog^.Team = TeamsArray[t]) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1170 |
hh:= CurrentHedgehog |
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset
|
1171 |
else |
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1172 |
begin |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1173 |
// otherwise use the first living hog or the hog amongs the remaining ones indicated by i |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1174 |
j:= 0; |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1175 |
c:= 0; |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1176 |
while (j <= cMaxHHIndex) and (hh = nil) do |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1177 |
begin |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1178 |
if (TeamsArray[t]^.Hedgehogs[j].Gear <> nil) then |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1179 |
begin |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1180 |
inc(c); |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1181 |
if (i=0) or (i=c) then |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1182 |
hh:= @TeamsArray[t]^.Hedgehogs[j] |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1183 |
end; |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1184 |
inc(j) |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1185 |
end |
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1186 |
end; |
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset
|
1187 |
if hh <> nil then |
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1188 |
begin |
4784 | 1189 |
Gear:= AddVisualGear(0, 0, vgtSpeechBubble); |
1190 |
if Gear <> nil then |
|
1191 |
begin |
|
1192 |
Gear^.Hedgehog:= hh; |
|
1193 |
Gear^.Text:= text; |
|
1194 |
Gear^.FrameTicks:= x |
|
9764
8dc9d268330f
revert r938d1c08d0d1 in favour of putting it in the chat log. I think this addresses main concern about missing text. There've been complaints in past too about conversation in bubbles not being visible in history. If the objection is that r938d1c08d0d1 offers a more æsthetic solution, I think it should augment this, be flagged, and fix the visual issues first.
nemo
parents:
9685
diff
changeset
|
1195 |
end; |
9777 | 1196 |
//ParseCommand('/say [' + hh^.Name + '] '+text, true) |
11022 | 1197 |
AddChatString(#9+'[' + HH^.Name + '] '+text); |
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1198 |
end |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1199 |
end |
4470
d2b8d2fc51a9
disable say, just don't do anything. trying to avoid spew on spectator join
nemo
parents:
4469
diff
changeset
|
1200 |
else if (x >= 4) then |
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1201 |
begin |
4465
743673c67d0c
Allow hog speech when not your turn. Currently is set to 40% opacity (could be fainter) and drawn behind the hogs instead of in front. Also allows hog targetting using a number.
nemo
parents:
4455
diff
changeset
|
1202 |
SpeechType:= x-3; |
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1203 |
SpeechText:= text |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1204 |
end; |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1205 |
end; |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1206 |
|
3038 | 1207 |
procedure initModule; |
6543 | 1208 |
const handlers: array[TGearType] of TGearStepProcedure = ( |
6890 | 1209 |
@doStepFlame, |
1210 |
@doStepHedgehog, |
|
1211 |
@doStepMine, |
|
1212 |
@doStepCase, |
|
10829 | 1213 |
@doStepAirMine, |
6890 | 1214 |
@doStepCase, |
6543 | 1215 |
@doStepBomb, |
1216 |
@doStepShell, |
|
1217 |
@doStepGrave, |
|
1218 |
@doStepBee, |
|
1219 |
@doStepShotgunShot, |
|
1220 |
@doStepPickHammer, |
|
1221 |
@doStepRope, |
|
1222 |
@doStepDEagleShot, |
|
1223 |
@doStepDynamite, |
|
1224 |
@doStepBomb, |
|
1225 |
@doStepCluster, |
|
1226 |
@doStepShover, |
|
1227 |
@doStepFirePunch, |
|
1228 |
@doStepActionTimer, |
|
1229 |
@doStepActionTimer, |
|
1230 |
@doStepParachute, |
|
1231 |
@doStepAirAttack, |
|
1232 |
@doStepAirBomb, |
|
1233 |
@doStepBlowTorch, |
|
1234 |
@doStepGirder, |
|
1235 |
@doStepTeleport, |
|
1236 |
@doStepSwitcher, |
|
1237 |
@doStepTarget, |
|
1238 |
@doStepMortar, |
|
1239 |
@doStepWhip, |
|
1240 |
@doStepKamikaze, |
|
1241 |
@doStepCake, |
|
1242 |
@doStepSeduction, |
|
1243 |
@doStepBomb, |
|
1244 |
@doStepCluster, |
|
1245 |
@doStepBomb, |
|
1246 |
@doStepWaterUp, |
|
1247 |
@doStepDrill, |
|
1248 |
@doStepBallgun, |
|
1249 |
@doStepBomb, |
|
1250 |
@doStepRCPlane, |
|
1251 |
@doStepSniperRifleShot, |
|
1252 |
@doStepJetpack, |
|
1253 |
@doStepMolotov, |
|
1254 |
@doStepBirdy, |
|
1255 |
@doStepEggWork, |
|
1256 |
@doStepPortalShot, |
|
1257 |
@doStepPiano, |
|
1258 |
@doStepBomb, |
|
1259 |
@doStepSineGunShot, |
|
1260 |
@doStepFlamethrower, |
|
1261 |
@doStepSMine, |
|
1262 |
@doStepPoisonCloud, |
|
1263 |
@doStepHammer, |
|
1264 |
@doStepHammerHit, |
|
1265 |
@doStepResurrector, |
|
1266 |
@doStepNapalmBomb, |
|
1267 |
@doStepSnowball, |
|
1268 |
@doStepSnowflake, |
|
8161 | 1269 |
//@doStepStructure, |
6543 | 1270 |
@doStepLandGun, |
7007 | 1271 |
@doStepTardis, |
7389
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7370
diff
changeset
|
1272 |
@doStepIceGun, |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7370
diff
changeset
|
1273 |
@doStepAddAmmo, |
7730
2013733f9ca9
A bit more on the knife. Also add missing files to CMakeLists
nemo
parents:
7721
diff
changeset
|
1274 |
@doStepGenericFaller, |
12192 | 1275 |
@doStepKnife, |
12898 | 1276 |
@doStepDuck, |
1277 |
@doStepMinigun, |
|
1278 |
@doStepMinigunBullet); |
|
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
1279 |
begin |
6543 | 1280 |
doStepHandlers:= handlers; |
1281 |
||
6898 | 1282 |
RegisterVariable('skip', @chSkip, false); |
1283 |
RegisterVariable('hogsay', @chHogSay, true ); |
|
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1284 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1285 |
CurAmmoGear:= nil; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1286 |
GearsList:= nil; |
7395 | 1287 |
curHandledGear:= nil; |
1288 |
||
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1289 |
KilledHHs:= 0; |
4792
68f9b331014a
sudden death changes: only change visual bit on health decrease and support for water transparancy change and clouds number change
Henek
parents:
4790
diff
changeset
|
1290 |
SuddenDeath:= false; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1291 |
SuddenDeathDmg:= false; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1292 |
SpeechType:= 1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1293 |
skipFlag:= false; |
3697 | 1294 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1295 |
AllInactive:= false; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1296 |
PrvInactive:= false; |
6982 | 1297 |
|
1298 |
//typed const |
|
1299 |
delay:= 0; |
|
1300 |
delay2:= 0; |
|
1301 |
step:= stDelay; |
|
1302 |
upd:= 0; |
|
7021
0c75512a8920
adjust the scope of a few uSound variables and functions
koda
parents:
7010
diff
changeset
|
1303 |
|
0c75512a8920
adjust the scope of a few uSound variables and functions
koda
parents:
7010
diff
changeset
|
1304 |
//SDMusic:= 'hell.ogg'; |
8349
a1dbe148f10f
move onNewTurn, onGameTick and onGameTick20 to try and avoid ParseCommand breakage after nextturn call. Needs testing, but should be safe for most scripts. Also fix locale loading.
nemo
parents:
8204
diff
changeset
|
1305 |
NewTurnTick:= $FFFFFFFF; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
1306 |
end; |
4 | 1307 |
|
3038 | 1308 |
procedure freeModule; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
1309 |
begin |
3615 | 1310 |
FreeGearsList(); |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
1311 |
end; |
4 | 1312 |
|
2451
5affd0840927
New data files from Tiy, add gtFlame to avoidance list
nemo
parents:
2428
diff
changeset
|
1313 |
end. |