author | wuzzy |
Sun, 21 Dec 2014 09:27:57 +0100 | |
changeset 10698 | aa3dfb4df603 |
parent 10634 | 35d059bd0932 |
child 10789 | acbf69e2e5cf |
permissions | -rw-r--r-- |
4 | 1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
9998 | 3 |
* Copyright (c) 2004-2014 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 |
9777 | 36 |
uses uConsts, uFloat, uTypes, uChat; |
3697 | 37 |
|
3038 | 38 |
procedure initModule; |
39 |
procedure freeModule; |
|
7337
c224cd2d32f3
Allow script to set number of ammo in a crate. untested.
nemo
parents:
7335
diff
changeset
|
40 |
function SpawnCustomCrateAt(x, y: LongInt; crate: TCrateType; content, cnt: Longword): PGear; |
5343 | 41 |
function SpawnFakeCrateAt(x, y: LongInt; crate: TCrateType; explode: boolean; poison: boolean ): PGear; |
4 | 42 |
procedure ProcessGears; |
3396
e5b3e5f2818e
More portal changes. Allows for a multishoot utility. Hopefully not breaking anything.
nemo
parents:
3390
diff
changeset
|
43 |
procedure EndTurnCleanup; |
956 | 44 |
procedure DrawGears; |
4 | 45 |
procedure FreeGearsList; |
10 | 46 |
procedure AddMiscGears; |
4 | 47 |
procedure AssignHHCoords; |
3405 | 48 |
function GearByUID(uid : Longword) : PGear; |
4 | 49 |
|
50 |
implementation |
|
9651 | 51 |
uses uStore, uSound, uTeams, uRandom, uIO, uLandGraphics, |
52 |
{$IFDEF USE_TOUCH_INTERFACE}uTouch,{$ENDIF} |
|
9295
f8819c3dde54
Remove some GLunit dependencies noticed on graph. uUtils was using it for GLfloat - but, the stuff it was returning to was usually converting to "real" anyway. uLand was including it unnecessarily. Minor refactor
nemo
parents:
9293
diff
changeset
|
53 |
uLocale, uAmmos, uStats, uVisualGears, uScript, uVariables, |
10015 | 54 |
uCommands, uUtils, uTextures, uRenderUtils, uGearsRender, uCaptions, uDebug, |
9285 | 55 |
uGearsHedgehog, uGearsUtils, uGearsList, uGearsHandlersRope |
9293
873022596d15
You better test build before committing even trivial patches
unc0rr
parents:
9291
diff
changeset
|
56 |
, uVisualGearsList, uGearsHandlersMess, uAI; |
789 | 57 |
|
7028 | 58 |
var skipFlag: boolean; |
3697 | 59 |
|
6982 | 60 |
var delay: LongWord; |
61 |
delay2: LongWord; |
|
62 |
step: (stDelay, stChDmg, stSweep, stTurnReact, |
|
63 |
stAfterDelay, stChWin, stWater, stChWin2, stHealth, |
|
64 |
stSpawn, stNTurn); |
|
8349
a1dbe148f10f
move onNewTurn, onGameTick and onGameTick20 to try and avoid ParseCommand breakage after nextturn call. Needs testing, but should be safe for most scripts. Also fix locale loading.
nemo
parents:
8204
diff
changeset
|
65 |
NewTurnTick: LongWord; |
7021
0c75512a8920
adjust the scope of a few uSound variables and functions
koda
parents:
7010
diff
changeset
|
66 |
//SDMusic: shortstring; |
6982 | 67 |
|
4 | 68 |
function CheckNoDamage: boolean; // returns TRUE in case of no damaged hhs |
69 |
var Gear: PGear; |
|
1849 | 70 |
dmg: LongInt; |
4 | 71 |
begin |
351 | 72 |
CheckNoDamage:= true; |
4 | 73 |
Gear:= GearsList; |
74 |
while Gear <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
75 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
76 |
if (Gear^.Kind = gtHedgehog) and (((GameFlags and gfInfAttack) = 0) or ((Gear^.dX.QWordValue < _0_000004.QWordValue) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
77 |
and (Gear^.dY.QWordValue < _0_000004.QWordValue))) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
78 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
79 |
if (not isInMultiShoot) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
80 |
inc(Gear^.Damage, Gear^.Karma); |
9685
7d925e82e572
Tweak trophyrace to work better w/ skip (probably, needs testing), drop Invulnerable in favour of effects - heInvulnerable is already in effects,
nemo
parents:
9672
diff
changeset
|
81 |
if (Gear^.Damage <> 0) and ((Gear^.Hedgehog^.Effects[heInvulnerable] = 0)) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
82 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
83 |
CheckNoDamage:= false; |
4824 | 84 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
85 |
dmg:= Gear^.Damage; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
86 |
if Gear^.Health < dmg then |
3453 | 87 |
begin |
88 |
Gear^.Active:= true; |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
89 |
Gear^.Health:= 0 |
3453 | 90 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
91 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
92 |
dec(Gear^.Health, dmg); |
7882
35dfc54ba2c6
disable this block since it doesn't fit star's new graphic. doesn't show up often anyway, since unc0rr changed gst clearing
nemo
parents:
7850
diff
changeset
|
93 |
(* |
35dfc54ba2c6
disable this block since it doesn't fit star's new graphic. doesn't show up often anyway, since unc0rr changed gst clearing
nemo
parents:
7850
diff
changeset
|
94 |
This doesn't fit well w/ the new loser sprite which is cringing from an attack. |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
95 |
if (Gear^.Hedgehog^.Team = CurrentTeam) and (Gear^.Damage <> Gear^.Karma) |
7010
10a0a31804f3
Switch effects to longint for convenience of tracking ice states. I could add a new Hedgehog value, but since we have this effects list being all useless as booleans anyway...
nemo
parents:
7007
diff
changeset
|
96 |
and (not Gear^.Hedgehog^.King) and (Gear^.Hedgehog^.Effects[hePoisoned] = 0) and (not SuddenDeathDmg) then |
2017 | 97 |
Gear^.State:= Gear^.State or gstLoser; |
7882
35dfc54ba2c6
disable this block since it doesn't fit star's new graphic. doesn't show up often anyway, since unc0rr changed gst clearing
nemo
parents:
7850
diff
changeset
|
98 |
*) |
2017 | 99 |
|
3461
0781275649e9
revert the restoration of non-vgt health gears. desyncs continued with it, and furthermore, occur in r3489 too
nemo
parents:
3460
diff
changeset
|
100 |
spawnHealthTagForHH(Gear, dmg); |
867 | 101 |
|
4365 | 102 |
RenderHealth(Gear^.Hedgehog^); |
103 |
RecountTeamHealth(Gear^.Hedgehog^.Team); |
|
1505 | 104 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
105 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
106 |
if (not isInMultiShoot) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
107 |
Gear^.Karma:= 0; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
108 |
Gear^.Damage:= 0 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
109 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
110 |
Gear:= Gear^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
111 |
end; |
4 | 112 |
end; |
113 |
||
1054 | 114 |
procedure HealthMachine; |
115 |
var Gear: PGear; |
|
2824
2d25e49bc2e8
Extra incentive to attack non-king hogs. If king loses his entourage, he loses 5hp per turn
nemo
parents:
2814
diff
changeset
|
116 |
team: PTeam; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
117 |
i: LongWord; |
2824
2d25e49bc2e8
Extra incentive to attack non-king hogs. If king loses his entourage, he loses 5hp per turn
nemo
parents:
2814
diff
changeset
|
118 |
flag: Boolean; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
119 |
tmp: LongWord; |
1054 | 120 |
begin |
3682 | 121 |
Gear:= GearsList; |
1054 | 122 |
|
3682 | 123 |
while Gear <> nil do |
124 |
begin |
|
125 |
if Gear^.Kind = gtHedgehog then |
|
126 |
begin |
|
127 |
tmp:= 0; |
|
7010
10a0a31804f3
Switch effects to longint for convenience of tracking ice states. I could add a new Hedgehog value, but since we have this effects list being all useless as booleans anyway...
nemo
parents:
7007
diff
changeset
|
128 |
if Gear^.Hedgehog^.Effects[hePoisoned] <> 0 then |
4111 | 129 |
begin |
10012
82dd9f0c88f7
Make poison damage possibly variable (might as well since effects is a count). Scripts might find it handy.
nemo
parents:
9998
diff
changeset
|
130 |
inc(tmp, ModifyDamage(Gear^.Hedgehog^.Effects[hePoisoned], Gear)); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
131 |
if (GameFlags and gfResetHealth) <> 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
132 |
dec(Gear^.Hedgehog^.InitialHealth) // does not need a minimum check since <= 1 basically disables it |
4111 | 133 |
end; |
4153
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
134 |
if (TotalRounds > cSuddenDTurns - 1) then |
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
135 |
begin |
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
136 |
inc(tmp, cHealthDecrease); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
137 |
if (GameFlags and gfResetHealth) <> 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
138 |
dec(Gear^.Hedgehog^.InitialHealth, cHealthDecrease) |
4153
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
139 |
end; |
4365 | 140 |
if Gear^.Hedgehog^.King then |
3109
06c089cb739c
Reduce turns to -1 to allow processing health machine on first turn. Needs testing with Sudden Death set to 0
nemo
parents:
3107
diff
changeset
|
141 |
begin |
06c089cb739c
Reduce turns to -1 to allow processing health machine on first turn. Needs testing with Sudden Death set to 0
nemo
parents:
3107
diff
changeset
|
142 |
flag:= false; |
4365 | 143 |
team:= Gear^.Hedgehog^.Team; |
3109
06c089cb739c
Reduce turns to -1 to allow processing health machine on first turn. Needs testing with Sudden Death set to 0
nemo
parents:
3107
diff
changeset
|
144 |
for i:= 0 to Pred(team^.HedgehogsNumber) do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
145 |
if (team^.Hedgehogs[i].Gear <> nil) and (not team^.Hedgehogs[i].King) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
146 |
and (team^.Hedgehogs[i].Gear^.Health > team^.Hedgehogs[i].Gear^.Damage) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
147 |
flag:= true; |
4111 | 148 |
if not flag then |
149 |
begin |
|
150 |
inc(tmp, 5); |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
151 |
if (GameFlags and gfResetHealth) <> 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
152 |
dec(Gear^.Hedgehog^.InitialHealth, 5) |
4111 | 153 |
end |
3109
06c089cb739c
Reduce turns to -1 to allow processing health machine on first turn. Needs testing with Sudden Death set to 0
nemo
parents:
3107
diff
changeset
|
154 |
end; |
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset
|
155 |
if tmp > 0 then |
3845
90034acb2e43
Untested fix of r3672 - should avoid hogs dying due to multiple health machine sources, and inappropriate application of karma/vampirism to these.
nemo
parents:
3836
diff
changeset
|
156 |
begin |
90034acb2e43
Untested fix of r3672 - should avoid hogs dying due to multiple health machine sources, and inappropriate application of karma/vampirism to these.
nemo
parents:
3836
diff
changeset
|
157 |
inc(Gear^.Damage, min(tmp, max(0,Gear^.Health - 1 - Gear^.Damage))); |
90034acb2e43
Untested fix of r3672 - should avoid hogs dying due to multiple health machine sources, and inappropriate application of karma/vampirism to these.
nemo
parents:
3836
diff
changeset
|
158 |
HHHurt(Gear^.Hedgehog, dsPoison); |
90034acb2e43
Untested fix of r3672 - should avoid hogs dying due to multiple health machine sources, and inappropriate application of karma/vampirism to these.
nemo
parents:
3836
diff
changeset
|
159 |
end |
3682 | 160 |
end; |
1054 | 161 |
|
3682 | 162 |
Gear:= Gear^.NextGear |
163 |
end; |
|
1054 | 164 |
end; |
165 |
||
4 | 166 |
procedure ProcessGears; |
7395 | 167 |
var t: PGear; |
4207
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
168 |
i, AliveCount: LongInt; |
10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10116
diff
changeset
|
169 |
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
|
170 |
prevtime: LongWord; |
4 | 171 |
begin |
9672
8663d299ba62
this should prevent sliding when game clock isn't running. sorry unc0rr, not going to bother encapsulating. maybe later. short on time right now/lazy
nemo
parents:
9651
diff
changeset
|
172 |
prevtime:= TurnTimeLeft; |
8349
a1dbe148f10f
move onNewTurn, onGameTick and onGameTick20 to try and avoid ParseCommand breakage after nextturn call. Needs testing, but should be safe for most scripts. Also fix locale loading.
nemo
parents:
8204
diff
changeset
|
173 |
ScriptCall('onGameTick'); |
a1dbe148f10f
move onNewTurn, onGameTick and onGameTick20 to try and avoid ParseCommand breakage after nextturn call. Needs testing, but should be safe for most scripts. Also fix locale loading.
nemo
parents:
8204
diff
changeset
|
174 |
if GameTicks mod 20 = 0 then ScriptCall('onGameTick20'); |
8351 | 175 |
if GameTicks = NewTurnTick then |
176 |
begin |
|
177 |
ScriptCall('onNewTurn'); |
|
9651 | 178 |
{$IFDEF USE_TOUCH_INTERFACE} |
8351 | 179 |
uTouch.NewTurnBeginning(); |
180 |
{$ENDIF} |
|
181 |
end; |
|
8349
a1dbe148f10f
move onNewTurn, onGameTick and onGameTick20 to try and avoid ParseCommand breakage after nextturn call. Needs testing, but should be safe for most scripts. Also fix locale loading.
nemo
parents:
8204
diff
changeset
|
182 |
|
868 | 183 |
PrvInactive:= AllInactive; |
4 | 184 |
AllInactive:= true; |
1495 | 185 |
|
2940 | 186 |
if (StepSoundTimer > 0) and (StepSoundChannel < 0) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
187 |
StepSoundChannel:= LoopSound(sndSteps) |
2940 | 188 |
else if (StepSoundTimer = 0) and (StepSoundChannel > -1) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
189 |
begin |
7053 | 190 |
StopSoundChan(StepSoundChannel); |
2993
d83edb74e92d
Remove animation on jumping/resuming walk, only leave it in on weapon switch
nemo
parents:
2991
diff
changeset
|
191 |
StepSoundChannel:= -1 |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
192 |
end; |
2940 | 193 |
|
194 |
if StepSoundTimer > 0 then |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
195 |
dec(StepSoundTimer, 1); |
2940 | 196 |
|
4 | 197 |
t:= GearsList; |
1054 | 198 |
while t <> nil do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
199 |
begin |
7395 | 200 |
curHandledGear:= t; |
201 |
t:= curHandledGear^.NextGear; |
|
3123 | 202 |
|
7517 | 203 |
if curHandledGear^.Message and gmDelete <> 0 then |
7519 | 204 |
DeleteGear(curHandledGear) |
205 |
else |
|
2204
526f8165acce
Smaxx' idea of timers, reworked just a tad. Might need variable for offset, but seems ok for now
nemo
parents:
2186
diff
changeset
|
206 |
begin |
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset
|
207 |
if curHandledGear^.Message and gmRemoveFromList <> 0 then |
7519 | 208 |
begin |
209 |
RemoveGearFromList(curHandledGear); |
|
210 |
// since I can't think of any good reason this would ever be separate from a remove from list, going to keep it inside this block |
|
211 |
if curHandledGear^.Message and gmAddToList <> 0 then InsertGearToList(curHandledGear); |
|
212 |
curHandledGear^.Message:= curHandledGear^.Message and (not (gmRemoveFromList or gmAddToList)) |
|
213 |
end; |
|
214 |
if curHandledGear^.Active then |
|
2204
526f8165acce
Smaxx' idea of timers, reworked just a tad. Might need variable for offset, but seems ok for now
nemo
parents:
2186
diff
changeset
|
215 |
begin |
7519 | 216 |
if curHandledGear^.RenderTimer and (curHandledGear^.Timer > 500) and ((curHandledGear^.Timer mod 1000) = 0) then |
217 |
begin |
|
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
|
218 |
FreeAndNilTexture(curHandledGear^.Tex); |
10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10116
diff
changeset
|
219 |
curHandledGear^.Tex:= RenderStringTex(ansistring(inttostr(curHandledGear^.Timer div 1000)), cWhiteColor, fntSmall); |
7519 | 220 |
end; |
221 |
curHandledGear^.doStep(curHandledGear); |
|
222 |
// might be useful later |
|
223 |
//ScriptCall('onGearStep', Gear^.uid); |
|
224 |
end |
|
2204
526f8165acce
Smaxx' idea of timers, reworked just a tad. Might need variable for offset, but seems ok for now
nemo
parents:
2186
diff
changeset
|
225 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
226 |
end; |
7395 | 227 |
curHandledGear:= nil; |
89 | 228 |
|
4 | 229 |
if AllInactive then |
1343 | 230 |
case step of |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
231 |
stDelay: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
232 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
233 |
if delay = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
234 |
delay:= cInactDelay |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
235 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
236 |
dec(delay); |
614 | 237 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
238 |
if delay = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
239 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
240 |
end; |
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset
|
241 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
242 |
stChDmg: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
243 |
if CheckNoDamage then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
244 |
inc(step) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
245 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
246 |
step:= stDelay; |
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset
|
247 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
248 |
stSweep: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
249 |
if SweepDirty then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
250 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
251 |
SetAllToActive; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
252 |
step:= stChDmg |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
253 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
254 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
255 |
inc(step); |
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset
|
256 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
257 |
stTurnReact: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
258 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
259 |
if (not bBetweenTurns) and (not isInMultiShoot) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
260 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
261 |
uStats.TurnReaction; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
262 |
inc(step) |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
263 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
264 |
else |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
265 |
inc(step, 2); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
266 |
end; |
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset
|
267 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
268 |
stAfterDelay: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
269 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
270 |
if delay = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
271 |
delay:= cInactDelay |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
272 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
273 |
dec(delay); |
815 | 274 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
275 |
if delay = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
276 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
277 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
278 |
stChWin: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
279 |
begin |
7669
a85e1c167b69
I didn't want to do this since it seems less clean, but...
sheepluva
parents:
7667
diff
changeset
|
280 |
CheckForWin(); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
281 |
inc(step) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
282 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
283 |
stWater: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
284 |
if (not bBetweenTurns) and (not isInMultiShoot) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
285 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
286 |
if TotalRounds = cSuddenDTurns + 1 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
287 |
bWaterRising:= true; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
288 |
if bWaterRising and (cWaterRise > 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
289 |
AddGear(0, 0, gtWaterUp, 0, _0, _0, 0)^.Tag:= cWaterRise; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
290 |
inc(step) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
291 |
end |
7667
4346566c5a58
skip second CheckForWin if water wasn't raised after first one
sheepluva
parents:
7666
diff
changeset
|
292 |
else // since we are not raising the water, a second win-check isn't needed |
4346566c5a58
skip second CheckForWin if water wasn't raised after first one
sheepluva
parents:
7666
diff
changeset
|
293 |
inc(step,2); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
294 |
stChWin2: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
295 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
296 |
CheckForWin; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
297 |
inc(step) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
298 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
299 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
300 |
stHealth: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
301 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
302 |
if (cWaterRise <> 0) or (cHealthDecrease <> 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
303 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
304 |
if (TotalRounds = cSuddenDTurns) and (not SuddenDeath) and (not isInMultiShoot) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
305 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
306 |
SuddenDeath:= true; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
307 |
if cHealthDecrease <> 0 then |
4215
36632d5b8492
inactivate sudden death if both health decrease and water rise is 0 and lower sudden death turns to 50 again
Henek
parents:
4210
diff
changeset
|
308 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
309 |
SuddenDeathDmg:= true; |
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset
|
310 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
311 |
// flash |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
312 |
ScreenFade:= sfFromWhite; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
313 |
ScreenFadeValue:= sfMax; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
314 |
ScreenFadeSpeed:= 1; |
9317
a04c30940d2d
use SDL2 as ifdef symbol because we're not really sdl1.3 compatible, change the compatibility layer, drop unused code, add some documentation
koda
parents:
9295
diff
changeset
|
315 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
316 |
ChangeToSDClouds; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
317 |
ChangeToSDFlakes; |
9295
f8819c3dde54
Remove some GLunit dependencies noticed on graph. uUtils was using it for GLfloat - but, the stuff it was returning to was usually converting to "real" anyway. uLand was including it unnecessarily. Minor refactor
nemo
parents:
9293
diff
changeset
|
318 |
SetSkyColor(SDSkyColor.r * (SDTint/255) / 255, SDSkyColor.g * (SDTint/255) / 255, SDSkyColor.b * (SDTint/255) / 255); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
319 |
Ammoz[amTardis].SkipTurns:= 9999; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
320 |
Ammoz[amTardis].Probability:= 0; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
321 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
322 |
AddCaption(trmsg[sidSuddenDeath], cWhiteColor, capgrpGameState); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
323 |
playSound(sndSuddenDeath); |
10254 | 324 |
StopMusic; |
325 |
if SDMusicFN <> '' then PlayMusic |
|
326 |
end |
|
327 |
else if (TotalRounds < cSuddenDTurns) and (not isInMultiShoot) then |
|
328 |
begin |
|
329 |
i:= cSuddenDTurns - TotalRounds; |
|
330 |
s:= ansistring(inttostr(i)); |
|
331 |
if i = 1 then |
|
332 |
AddCaption(trmsg[sidRoundSD], cWhiteColor, capgrpGameState) |
|
333 |
else if (i = 2) or ((i > 0) and ((i mod 50 = 0) or ((i <= 25) and (i mod 5 = 0)))) then |
|
334 |
AddCaption(FormatA(trmsg[sidRoundsSD], s), cWhiteColor, capgrpGameState); |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
335 |
end; |
10254 | 336 |
end; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
337 |
if bBetweenTurns |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
338 |
or isInMultiShoot |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
339 |
or (TotalRounds = -1) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
340 |
inc(step) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
341 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
342 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
343 |
bBetweenTurns:= true; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
344 |
HealthMachine; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
345 |
step:= stChDmg |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
346 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
347 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
348 |
stSpawn: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
349 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
350 |
if not isInMultiShoot then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
351 |
SpawnBoxOfSmth; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
352 |
inc(step) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
353 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
354 |
stNTurn: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
355 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
356 |
if isInMultiShoot then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
357 |
isInMultiShoot:= false |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
358 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
359 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
360 |
// delayed till after 0.9.12 |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
361 |
// reset to default zoom |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
362 |
//ZoomValue:= ZoomDefault; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
363 |
with CurrentHedgehog^ do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
364 |
if (Gear <> nil) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
365 |
and ((Gear^.State and gstAttacked) = 0) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
366 |
and (MultiShootAttacks > 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
367 |
OnUsedAmmo(CurrentHedgehog^); |
3697 | 368 |
|
3396
e5b3e5f2818e
More portal changes. Allows for a multishoot utility. Hopefully not breaking anything.
nemo
parents:
3390
diff
changeset
|
369 |
EndTurnCleanup; |
2376 | 370 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
371 |
FreeActionsList; // could send -left, -right and similar commands, so should be called before /nextturn |
1298 | 372 |
|
7181
0791c1f2734c
Welp. We have a bit of a problem here. Reverting the move of nextturn. But this causes a desync in scripting unless we can find a better fix.
nemo
parents:
7174
diff
changeset
|
373 |
ParseCommand('/nextturn', true); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
374 |
SwitchHedgehog; |
1298 | 375 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
376 |
AfterSwitchHedgehog; |
8349
a1dbe148f10f
move onNewTurn, onGameTick and onGameTick20 to try and avoid ParseCommand breakage after nextturn call. Needs testing, but should be safe for most scripts. Also fix locale loading.
nemo
parents:
8204
diff
changeset
|
377 |
bBetweenTurns:= false; |
a1dbe148f10f
move onNewTurn, onGameTick and onGameTick20 to try and avoid ParseCommand breakage after nextturn call. Needs testing, but should be safe for most scripts. Also fix locale loading.
nemo
parents:
8204
diff
changeset
|
378 |
NewTurnTick:= GameTicks + 1 |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
379 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
380 |
step:= Low(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
381 |
end; |
3949
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
382 |
end |
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
383 |
else if ((GameFlags and gfInfAttack) <> 0) then |
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
384 |
begin |
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
385 |
if delay2 = 0 then |
5296
0bb518ad2da8
At mikade's request and w/ unc0rr's blessing, dramatically slash inactivity delay from 1.25s down to a tenth of a second.
nemo
parents:
5284
diff
changeset
|
386 |
delay2:= cInactDelay * 50 |
3949
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
387 |
else |
3957 | 388 |
begin |
3949
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
389 |
dec(delay2); |
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
390 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
391 |
if ((delay2 mod cInactDelay) = 0) and (CurrentHedgehog <> nil) and (CurrentHedgehog^.Gear <> nil) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
392 |
and (not CurrentHedgehog^.Unplaced) then |
5507
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5501
diff
changeset
|
393 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
394 |
if (CurrentHedgehog^.Gear^.State and gstAttacked <> 0) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
395 |
and (Ammoz[CurrentHedgehog^.CurAmmoType].Ammo.Propz and ammoprop_NeedTarget <> 0) then |
5507
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5501
diff
changeset
|
396 |
begin |
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5501
diff
changeset
|
397 |
CurrentHedgehog^.Gear^.State:= CurrentHedgehog^.Gear^.State or gstHHChooseTarget; |
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5501
diff
changeset
|
398 |
isCursorVisible := true |
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5501
diff
changeset
|
399 |
end; |
6453
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6380
diff
changeset
|
400 |
CurrentHedgehog^.Gear^.State:= CurrentHedgehog^.Gear^.State and (not gstAttacked); |
5507
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5501
diff
changeset
|
401 |
end; |
3957 | 402 |
if delay2 = 0 then |
403 |
begin |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
404 |
if (CurrentHedgehog^.Gear <> nil) and (CurrentHedgehog^.Gear^.State and gstAttacked = 0) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
405 |
and (CurAmmoGear = nil) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
406 |
SweepDirty; |
9497 | 407 |
if (CurrentHedgehog^.Gear = nil) or (CurrentHedgehog^.Gear^.State and gstHHDriven = 0) or (CurrentHedgehog^.Gear^.Damage = 0) then |
408 |
CheckNoDamage; |
|
4207
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
409 |
AliveCount:= 0; // shorter version of check for win to allow typical step activity to proceed |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
410 |
for i:= 0 to Pred(ClansCount) do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
411 |
if ClansArray[i]^.ClanHealth > 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
412 |
inc(AliveCount); |
4207
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
413 |
if (AliveCount <= 1) and ((GameFlags and gfOneClanMode) = 0) then |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
414 |
begin |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
415 |
step:= stChDmg; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
416 |
if TagTurnTimeLeft = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
417 |
TagTurnTimeLeft:= TurnTimeLeft; |
4207
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
418 |
TurnTimeLeft:= 0 |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
419 |
end |
3957 | 420 |
end |
3949
4c4c0a2507cc
Add the standard delay (1.25 seconds) between attacks on inf attack mode, as well as checks for damage and win.
nemo
parents:
3946
diff
changeset
|
421 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
422 |
end; |
15 | 423 |
|
4 | 424 |
if TurnTimeLeft > 0 then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
425 |
if CurrentHedgehog^.Gear <> nil then |
9573 | 426 |
if (((CurrentHedgehog^.Gear^.State and gstAttacking) = 0) |
9583 | 427 |
or (Ammoz[CurrentHedgehog^.CurAmmoType].Ammo.Propz and ammoprop_DoesntStopTimerWhileAttacking <> 0)) |
10078 | 428 |
and (not(isInMultiShoot and ((Ammoz[CurrentHedgehog^.CurAmmoType].Ammo.Propz and ammoprop_DoesntStopTimerInMultiShoot) <> 0))) then |
9573 | 429 |
//(CurrentHedgehog^.CurAmmoType in [amShotgun, amDEagle, amSniperRifle]) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
430 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
431 |
if (TurnTimeLeft = 5000) |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
432 |
and (cHedgehogTurnTime >= 10000) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
433 |
and (not PlacingHogs) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
434 |
and (CurrentHedgehog^.Gear <> nil) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
435 |
and ((CurrentHedgehog^.Gear^.State and gstAttacked) = 0) then |
7053 | 436 |
PlaySoundV(sndHurry, CurrentTeam^.voicepack); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
437 |
if ReadyTimeLeft > 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
438 |
begin |
6596
4c06ea12de1c
Tweak voices a bit (always play hurry at correct time, skip "come on then" if other voice is playing)
nemo
parents:
6580
diff
changeset
|
439 |
if (ReadyTimeLeft = 2000) and (LastVoice.snd = sndNone) then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
440 |
AddVoice(sndComeonthen, CurrentTeam^.voicepack); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
441 |
dec(ReadyTimeLeft) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
442 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
443 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
444 |
dec(TurnTimeLeft) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
445 |
end; |
351 | 446 |
|
2621
956ff066f3a5
Fix desync when playing with AI via network, occuring in certain conditions
unc0rr
parents:
2619
diff
changeset
|
447 |
if skipFlag then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
448 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
449 |
if TagTurnTimeLeft = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
450 |
TagTurnTimeLeft:= TurnTimeLeft; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
451 |
TurnTimeLeft:= 0; |
3784
75aa91bea32b
Extend statistics collection (TeamKills, TurnSkips, TeamDamage)
burp
parents:
3775
diff
changeset
|
452 |
skipFlag:= false; |
75aa91bea32b
Extend statistics collection (TeamKills, TurnSkips, TeamDamage)
burp
parents:
3775
diff
changeset
|
453 |
inc(CurrentHedgehog^.Team^.stats.TurnSkips); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
454 |
end; |
2621
956ff066f3a5
Fix desync when playing with AI via network, occuring in certain conditions
unc0rr
parents:
2619
diff
changeset
|
455 |
|
2134 | 456 |
if ((GameTicks and $FFFF) = $FFFF) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
457 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
458 |
if (not CurrentTeam^.ExtDriven) then |
5810 | 459 |
begin |
7068 | 460 |
SendIPC(_S'#'); |
5810 | 461 |
AddFileLog('hiTicks increment message sent') |
462 |
end; |
|
2134 | 463 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
464 |
if (not CurrentTeam^.ExtDriven) or CurrentTeam^.hasGone then |
10395
0d20f6fc038a
Better diagnostics in log, even though it shouldn't matter anymore
unc0rr
parents:
10254
diff
changeset
|
465 |
begin |
0d20f6fc038a
Better diagnostics in log, even though it shouldn't matter anymore
unc0rr
parents:
10254
diff
changeset
|
466 |
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
|
467 |
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
|
468 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
469 |
end; |
7407 | 470 |
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
|
471 |
TurnClockActive:= prevtime <> TurnTimeLeft; |
515 | 472 |
inc(GameTicks) |
4 | 473 |
end; |
474 |
||
3396
e5b3e5f2818e
More portal changes. Allows for a multishoot utility. Hopefully not breaking anything.
nemo
parents:
3390
diff
changeset
|
475 |
//Purpose, to reset all transient attributes toggled by a utility and clean up various gears and effects at end of turn |
1854 | 476 |
//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
|
477 |
procedure EndTurnCleanup; |
1865
ebc6dfca60d4
- nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1863
diff
changeset
|
478 |
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
|
479 |
t: PGear; |
1849 | 480 |
begin |
2221 | 481 |
SpeechText:= ''; // in case it has not been consumed |
2017 | 482 |
|
1895 | 483 |
if (GameFlags and gfLowGravity) = 0 then |
4623 | 484 |
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
|
485 |
cGravity:= cMaxWindSpeed * 2; |
4623 | 486 |
cGravityf:= 0.00025 * 2 |
487 |
end; |
|
1895 | 488 |
|
2017 | 489 |
if (GameFlags and gfVampiric) = 0 then |
490 |
cVampiric:= false; |
|
491 |
||
1849 | 492 |
cDamageModifier:= _1; |
1895 | 493 |
|
494 |
if (GameFlags and gfLaserSight) = 0 then |
|
495 |
cLaserSighting:= false; |
|
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
496 |
|
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
497 |
if (GameFlags and gfArtillery) = 0 then |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
498 |
cArtillery:= false; |
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
499 |
// 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
|
500 |
if (CurrentTeam <> nil) then |
4099 | 501 |
with CurrentTeam^ do |
502 |
for i:= 0 to cMaxHHIndex do |
|
503 |
with Hedgehogs[i] do |
|
504 |
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
|
505 |
(* |
4099 | 506 |
if (SpeechGear <> nil) then |
507 |
begin |
|
508 |
DeleteVisualGear(SpeechGear); // remove to restore persisting beyond end of turn. Tiy says was too much of a gameplay issue |
|
509 |
SpeechGear:= nil |
|
510 |
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
|
511 |
*) |
2045
b0588498bc3a
- Fix network (my crappy fault, triggered by nemo's patch)
unc0rr
parents:
2042
diff
changeset
|
512 |
|
4099 | 513 |
if (Gear <> nil) then |
514 |
begin |
|
515 |
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
|
516 |
Gear^.Hedgehog^.Effects[heInvulnerable]:= 0; |
4099 | 517 |
end; |
518 |
end; |
|
3480
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
519 |
t:= GearsList; |
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
520 |
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
|
521 |
begin |
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
522 |
t^.PortalCounter:= 0; |
4372 | 523 |
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
|
524 |
begin |
4372 | 525 |
t^.Health:= t^.Hedgehog^.InitialHealth; |
526 |
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
|
527 |
end; |
3480
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
528 |
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
|
529 |
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
|
530 |
|
6453
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6380
diff
changeset
|
531 |
if ((GameFlags and gfResetWeps) <> 0) and (not PlacingHogs) then |
4099 | 532 |
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
|
533 |
|
4099 | 534 |
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
|
535 |
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
|
536 |
RecountTeamHealth(TeamsArray[i]) |
1849 | 537 |
end; |
2045
b0588498bc3a
- Fix network (my crappy fault, triggered by nemo's patch)
unc0rr
parents:
2042
diff
changeset
|
538 |
|
4385 | 539 |
procedure DrawGears; |
540 |
var Gear: PGear; |
|
541 |
x, y: LongInt; |
|
2802 | 542 |
begin |
4385 | 543 |
Gear:= GearsList; |
544 |
while Gear <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
545 |
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
|
546 |
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
|
547 |
begin |
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset
|
548 |
x:= hwRound(Gear^.X) + WorldDx; |
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset
|
549 |
y:= hwRound(Gear^.Y) + WorldDy; |
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset
|
550 |
RenderGear(Gear, x, y); |
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset
|
551 |
end; |
4385 | 552 |
Gear:= Gear^.NextGear |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
553 |
end; |
2802 | 554 |
end; |
555 |
||
4 | 556 |
procedure FreeGearsList; |
557 |
var t, tt: PGear; |
|
558 |
begin |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
559 |
tt:= GearsList; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
560 |
GearsList:= nil; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
561 |
while tt <> nil do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
562 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
563 |
t:= tt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
564 |
tt:= tt^.NextGear; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
565 |
Dispose(t) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
566 |
end; |
4 | 567 |
end; |
568 |
||
10 | 569 |
procedure AddMiscGears; |
10494 | 570 |
var p,i,j, unplaced: Longword; |
571 |
rx, ry: LongInt; |
|
7406
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset
|
572 |
rdx, rdy: hwFloat; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
573 |
Gear: PGear; |
4 | 574 |
begin |
498 | 575 |
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
|
576 |
|
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
|
577 |
i:= 0; |
10236
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
578 |
unplaced:= 0; |
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
579 |
while (i < cLandMines) and (unplaced < 4) do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
580 |
begin |
4148
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
581 |
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
|
582 |
FindPlace(Gear, false, 0, LAND_WIDTH); |
10236
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
583 |
|
10510 | 584 |
if Gear = nil then |
10236
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
585 |
inc(unplaced) |
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
586 |
else |
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
587 |
unplaced:= 0; |
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
588 |
|
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
|
589 |
inc(i) |
4148
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
590 |
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
|
591 |
|
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
|
592 |
i:= 0; |
10236
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
593 |
unplaced:= 0; |
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
594 |
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
|
595 |
begin |
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
596 |
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
|
597 |
FindPlace(Gear, false, 0, LAND_WIDTH); |
10236
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
598 |
|
10510 | 599 |
if Gear = nil then |
10236
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
600 |
inc(unplaced) |
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
601 |
else |
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
602 |
unplaced:= 0; |
8fa1ccfba752
- Increase limits on number of mines and explosives in game scheme
unc0rr
parents:
10124
diff
changeset
|
603 |
|
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
|
604 |
inc(i) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
605 |
end; |
1895 | 606 |
|
607 |
if (GameFlags and gfLowGravity) <> 0 then |
|
4623 | 608 |
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
|
609 |
cGravity:= cMaxWindSpeed; |
4623 | 610 |
cGravityf:= 0.00025 |
611 |
end; |
|
1895 | 612 |
|
2017 | 613 |
if (GameFlags and gfVampiric) <> 0 then |
614 |
cVampiric:= true; |
|
615 |
||
1895 | 616 |
Gear:= GearsList; |
617 |
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
|
618 |
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
|
619 |
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
|
620 |
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
|
621 |
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
|
622 |
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
|
623 |
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
|
624 |
Effects[heInvulnerable]:= 1; |
1895 | 625 |
|
626 |
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
|
627 |
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
|
628 |
|
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
629 |
if (GameFlags and gfArtillery) <> 0 then |
4611 | 630 |
cArtillery:= true; |
8030
165aeaaaf445
Call fallers less often. Should hopefully still be about as effective at the intended purpose. Should help loads quite a bit.
nemo
parents:
8011
diff
changeset
|
631 |
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
|
632 |
begin |
f415b3e0f3b9
Burn a random number in the override. Make sure cirbuf is reset.
nemo
parents:
7519
diff
changeset
|
633 |
rx:= GetRandom(rightX-leftX)+leftX; |
7406
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset
|
634 |
ry:= GetRandom(LAND_HEIGHT-topY)+topY; |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset
|
635 |
rdx:= _90-(GetRandomf*_360); |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset
|
636 |
rdy:= _90-(GetRandomf*_360); |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset
|
637 |
AddGear(rx, ry, gtGenericFaller, gstInvisible, rdx, rdy, $FFFFFFFF); |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset
|
638 |
end; |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset
|
639 |
|
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
|
640 |
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
|
641 |
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
|
642 |
|
9768
08799c901a42
Add rubber utility. Graphics are still incomplete. Also flag snow/ice in theme config.
nemo
parents:
9764
diff
changeset
|
643 |
if (not hasBorder) and cSnow then |
7721 | 644 |
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
|
645 |
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
|
646 |
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
|
647 |
ry:=GetRandom(750); |
10494 | 648 |
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
|
649 |
end |
4 | 650 |
end; |
651 |
||
652 |
procedure AssignHHCoords; |
|
955 | 653 |
var i, t, p, j: LongInt; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
654 |
ar: array[0..Pred(cMaxHHs)] of PHedgehog; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
655 |
Count: Longword; |
4 | 656 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
657 |
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
|
658 |
PlacingHogs:= true; |
4148
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
659 |
if (GameFlags and gfDivideTeams) <> 0 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
660 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
661 |
t:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
662 |
TryDo(ClansCount = 2, 'More or less than 2 clans on map in divided teams mode!', true); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
663 |
for p:= 0 to 1 do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
664 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
665 |
with ClansArray[p]^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
666 |
for j:= 0 to Pred(TeamsNumber) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
667 |
with Teams[j]^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
668 |
for i:= 0 to cMaxHHIndex do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
669 |
with Hedgehogs[i] do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
670 |
if (Gear <> nil) and (Gear^.X.QWordValue = 0) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
671 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
672 |
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
|
673 |
Unplaced:= true |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
674 |
else |
7174
80480d21e6ed
Workaround for bug #144. This workaround had occurred to me a while ago, but wasn't sure if placing them unfairly was better than not placing them at all. Argument for not placing at all is people should probably abort the game when they notice it. Argument for placing unfairly is people can still abort, and if we really wanted them to abort, we should probably just have halted launch if all hogs failed to spawn. This way at least play can continue.
nemo
parents:
7165
diff
changeset
|
675 |
FindPlace(Gear, false, t, t + LAND_WIDTH div 2, true);// could make Gear == nil; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
676 |
if Gear <> nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
677 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
678 |
Gear^.Pos:= GetRandom(49); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
679 |
Gear^.dX.isNegative:= p = 1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
680 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
681 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
682 |
t:= LAND_WIDTH div 2 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
683 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
684 |
end else // mix hedgehogs |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
685 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
686 |
Count:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
687 |
for p:= 0 to Pred(TeamsCount) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
688 |
with TeamsArray[p]^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
689 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
690 |
for i:= 0 to cMaxHHIndex do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
691 |
with Hedgehogs[i] do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
692 |
if (Gear <> nil) and (Gear^.X.QWordValue = 0) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
693 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
694 |
ar[Count]:= @Hedgehogs[i]; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
695 |
inc(Count) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
696 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
697 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
698 |
while (Count > 0) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
699 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
700 |
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
|
701 |
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
|
702 |
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
|
703 |
else |
7174
80480d21e6ed
Workaround for bug #144. This workaround had occurred to me a while ago, but wasn't sure if placing them unfairly was better than not placing them at all. Argument for not placing at all is people should probably abort the game when they notice it. Argument for placing unfairly is people can still abort, and if we really wanted them to abort, we should probably just have halted launch if all hogs failed to spawn. This way at least play can continue.
nemo
parents:
7165
diff
changeset
|
704 |
FindPlace(ar[i]^.Gear, false, 0, LAND_WIDTH, true); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
705 |
if ar[i]^.Gear <> nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
706 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
707 |
ar[i]^.Gear^.dX.isNegative:= hwRound(ar[i]^.Gear^.X) > LAND_WIDTH div 2; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
708 |
ar[i]^.Gear^.Pos:= GetRandom(19) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
709 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
710 |
ar[i]:= ar[Count - 1]; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
711 |
dec(Count) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
712 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
713 |
end |
4 | 714 |
end; |
715 |
||
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
716 |
|
1433 | 717 |
{procedure AmmoFlameWork(Ammo: PGear); |
79 | 718 |
var t: PGear; |
719 |
begin |
|
720 |
t:= GearsList; |
|
721 |
while t <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
722 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
723 |
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
|
724 |
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
|
725 |
begin |
2017 | 726 |
ApplyDamage(t, 5); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
727 |
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
|
728 |
t^.dY:= - _0_25; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
729 |
t^.Active:= true; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
730 |
DeleteCI(t); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
731 |
FollowGear:= t |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
732 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
733 |
t:= t^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
734 |
end; |
1433 | 735 |
end;} |
79 | 736 |
|
16 | 737 |
|
7337
c224cd2d32f3
Allow script to set number of ammo in a crate. untested.
nemo
parents:
7335
diff
changeset
|
738 |
function SpawnCustomCrateAt(x, y: LongInt; crate: TCrateType; content, cnt: Longword): PGear; |
3730 | 739 |
begin |
3734 | 740 |
FollowGear := AddGear(x, y, gtCase, 0, _0, _0, 0); |
741 |
cCaseFactor := 0; |
|
742 |
||
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
743 |
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
|
744 |
content := ord(High(TAmmoType)); |
3734 | 745 |
|
7337
c224cd2d32f3
Allow script to set number of ammo in a crate. untested.
nemo
parents:
7335
diff
changeset
|
746 |
FollowGear^.Power:= cnt; |
c224cd2d32f3
Allow script to set number of ammo in a crate. untested.
nemo
parents:
7335
diff
changeset
|
747 |
|
3734 | 748 |
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
|
749 |
HealthCrate: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
750 |
begin |
3734 | 751 |
FollowGear^.Pos := posCaseHealth; |
10506 | 752 |
// health crate is smaller than the other crates |
753 |
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
|
754 |
FollowGear^.Health := content; |
3734 | 755 |
AddCaption(GetEventString(eidNewHealthPack), cWhiteColor, capgrpAmmoInfo); |
756 |
end; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
757 |
AmmoCrate: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
758 |
begin |
3734 | 759 |
FollowGear^.Pos := posCaseAmmo; |
4240
4e81670e52aa
er. and cast to TAmmoType, which burp's routine still requires :)
nemo
parents:
4239
diff
changeset
|
760 |
FollowGear^.AmmoType := TAmmoType(content); |
3734 | 761 |
AddCaption(GetEventString(eidNewAmmoPack), cWhiteColor, capgrpAmmoInfo); |
762 |
end; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
763 |
UtilityCrate: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
764 |
begin |
3734 | 765 |
FollowGear^.Pos := posCaseUtility; |
4240
4e81670e52aa
er. and cast to TAmmoType, which burp's routine still requires :)
nemo
parents:
4239
diff
changeset
|
766 |
FollowGear^.AmmoType := TAmmoType(content); |
3734 | 767 |
AddCaption(GetEventString(eidNewUtilityPack), cWhiteColor, capgrpAmmoInfo); |
768 |
end; |
|
769 |
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
|
770 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
771 |
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
|
772 |
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
|
773 |
|
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
|
774 |
SpawnCustomCrateAt := FollowGear; |
3730 | 775 |
end; |
776 |
||
5343 | 777 |
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
|
778 |
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
|
779 |
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
|
780 |
cCaseFactor := 0; |
5343 | 781 |
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
|
782 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
783 |
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
|
784 |
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
|
785 |
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
|
786 |
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
|
787 |
|
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
|
788 |
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
|
789 |
HealthCrate: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
790 |
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
|
791 |
FollowGear^.Pos := FollowGear^.Pos + posCaseHealth; |
10506 | 792 |
// health crate is smaller than the other crates |
793 |
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
|
794 |
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
|
795 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
796 |
AmmoCrate: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
797 |
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
|
798 |
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
|
799 |
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
|
800 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
801 |
UtilityCrate: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
802 |
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
|
803 |
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
|
804 |
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
|
805 |
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
|
806 |
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
|
807 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
808 |
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
|
809 |
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
|
810 |
|
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
|
811 |
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
|
812 |
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
|
813 |
|
2726 | 814 |
|
2790 | 815 |
function GearByUID(uid : Longword) : PGear; |
816 |
var gear: PGear; |
|
817 |
begin |
|
818 |
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
|
819 |
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
|
820 |
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
|
821 |
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
|
822 |
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
|
823 |
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
|
824 |
end; |
2790 | 825 |
gear:= GearsList; |
826 |
while gear <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
827 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
828 |
if gear^.uid = uid then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
829 |
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
|
830 |
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
|
831 |
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
|
832 |
exit |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
833 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
834 |
gear:= gear^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
835 |
end |
2790 | 836 |
end; |
837 |
||
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
|
838 |
|
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
|
839 |
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
|
840 |
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
|
841 |
s:= s; // avoid compiler hint |
7805 | 842 |
if not isExternalSource then |
7068 | 843 |
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
|
844 |
uStats.Skipped; |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
845 |
skipFlag:= true |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
846 |
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
|
847 |
|
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
|
848 |
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
|
849 |
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
|
850 |
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
|
851 |
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
|
852 |
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
|
853 |
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
|
854 |
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
|
855 |
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
|
856 |
i:= 0; |
4469 | 857 |
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
|
858 |
x:= byte(s[1]); // speech type |
4469 | 859 |
if x < 4 then |
860 |
begin |
|
861 |
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
|
862 |
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
|
863 |
h:= byte(s[3]) // target hog |
10490 | 864 |
else |
865 |
h:= 0 |
|
4469 | 866 |
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
|
867 |
// 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
|
868 |
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
|
869 |
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
|
870 |
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
|
871 |
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
|
872 |
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
|
873 |
text:= copy(s, 3, Length(s) - 1) |
4468 | 874 |
else text:= copy(s, 2, Length(s) - 1); |
875 |
||
9818 | 876 |
if text = '' then text:= '...'; |
877 |
||
4470
d2b8d2fc51a9
disable say, just don't do anything. trying to avoid spew on spectator join
nemo
parents:
4469
diff
changeset
|
878 |
(* |
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
|
879 |
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
|
880 |
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
|
881 |
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
|
882 |
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
|
883 |
end; |
4470
d2b8d2fc51a9
disable say, just don't do anything. trying to avoid spew on spectator join
nemo
parents:
4469
diff
changeset
|
884 |
*) |
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
|
885 |
|
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
|
886 |
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
|
887 |
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
|
888 |
// 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
|
889 |
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
|
890 |
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
|
891 |
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
|
892 |
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
|
893 |
// 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
|
894 |
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
|
895 |
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
|
896 |
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
|
897 |
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
|
898 |
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
|
899 |
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
|
900 |
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
|
901 |
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
|
902 |
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
|
903 |
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
|
904 |
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
|
905 |
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
|
906 |
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
|
907 |
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
|
908 |
begin |
4784 | 909 |
Gear:= AddVisualGear(0, 0, vgtSpeechBubble); |
910 |
if Gear <> nil then |
|
911 |
begin |
|
912 |
Gear^.Hedgehog:= hh; |
|
913 |
Gear^.Text:= text; |
|
914 |
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
|
915 |
end; |
9777 | 916 |
//ParseCommand('/say [' + hh^.Name + '] '+text, true) |
9779 | 917 |
AddChatString(#1+'[' + HH^.Name + '] '+text); |
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
918 |
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
|
919 |
end |
4470
d2b8d2fc51a9
disable say, just don't do anything. trying to avoid spew on spectator join
nemo
parents:
4469
diff
changeset
|
920 |
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
|
921 |
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
|
922 |
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
|
923 |
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
|
924 |
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
|
925 |
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
|
926 |
|
3038 | 927 |
procedure initModule; |
6543 | 928 |
const handlers: array[TGearType] of TGearStepProcedure = ( |
6890 | 929 |
@doStepFlame, |
930 |
@doStepHedgehog, |
|
931 |
@doStepMine, |
|
932 |
@doStepCase, |
|
933 |
@doStepCase, |
|
6543 | 934 |
@doStepBomb, |
935 |
@doStepShell, |
|
936 |
@doStepGrave, |
|
937 |
@doStepBee, |
|
938 |
@doStepShotgunShot, |
|
939 |
@doStepPickHammer, |
|
940 |
@doStepRope, |
|
941 |
@doStepDEagleShot, |
|
942 |
@doStepDynamite, |
|
943 |
@doStepBomb, |
|
944 |
@doStepCluster, |
|
945 |
@doStepShover, |
|
946 |
@doStepFirePunch, |
|
947 |
@doStepActionTimer, |
|
948 |
@doStepActionTimer, |
|
949 |
@doStepParachute, |
|
950 |
@doStepAirAttack, |
|
951 |
@doStepAirBomb, |
|
952 |
@doStepBlowTorch, |
|
953 |
@doStepGirder, |
|
954 |
@doStepTeleport, |
|
955 |
@doStepSwitcher, |
|
956 |
@doStepTarget, |
|
957 |
@doStepMortar, |
|
958 |
@doStepWhip, |
|
959 |
@doStepKamikaze, |
|
960 |
@doStepCake, |
|
961 |
@doStepSeduction, |
|
962 |
@doStepBomb, |
|
963 |
@doStepCluster, |
|
964 |
@doStepBomb, |
|
965 |
@doStepWaterUp, |
|
966 |
@doStepDrill, |
|
967 |
@doStepBallgun, |
|
968 |
@doStepBomb, |
|
969 |
@doStepRCPlane, |
|
970 |
@doStepSniperRifleShot, |
|
971 |
@doStepJetpack, |
|
972 |
@doStepMolotov, |
|
973 |
@doStepBirdy, |
|
974 |
@doStepEggWork, |
|
975 |
@doStepPortalShot, |
|
976 |
@doStepPiano, |
|
977 |
@doStepBomb, |
|
978 |
@doStepSineGunShot, |
|
979 |
@doStepFlamethrower, |
|
980 |
@doStepSMine, |
|
981 |
@doStepPoisonCloud, |
|
982 |
@doStepHammer, |
|
983 |
@doStepHammerHit, |
|
984 |
@doStepResurrector, |
|
985 |
@doStepNapalmBomb, |
|
986 |
@doStepSnowball, |
|
987 |
@doStepSnowflake, |
|
8161 | 988 |
//@doStepStructure, |
6543 | 989 |
@doStepLandGun, |
7007 | 990 |
@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
|
991 |
@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
|
992 |
@doStepAddAmmo, |
7730
2013733f9ca9
A bit more on the knife. Also add missing files to CMakeLists
nemo
parents:
7721
diff
changeset
|
993 |
@doStepGenericFaller, |
2013733f9ca9
A bit more on the knife. Also add missing files to CMakeLists
nemo
parents:
7721
diff
changeset
|
994 |
@doStepKnife); |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
995 |
begin |
6543 | 996 |
doStepHandlers:= handlers; |
997 |
||
6898 | 998 |
RegisterVariable('skip', @chSkip, false); |
999 |
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
|
1000 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1001 |
CurAmmoGear:= nil; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1002 |
GearsList:= nil; |
7395 | 1003 |
curHandledGear:= nil; |
1004 |
||
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1005 |
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
|
1006 |
SuddenDeath:= false; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1007 |
SuddenDeathDmg:= false; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1008 |
SpeechType:= 1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1009 |
skipFlag:= false; |
3697 | 1010 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1011 |
AllInactive:= false; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1012 |
PrvInactive:= false; |
6982 | 1013 |
|
1014 |
//typed const |
|
1015 |
delay:= 0; |
|
1016 |
delay2:= 0; |
|
1017 |
step:= stDelay; |
|
1018 |
upd:= 0; |
|
7021
0c75512a8920
adjust the scope of a few uSound variables and functions
koda
parents:
7010
diff
changeset
|
1019 |
|
0c75512a8920
adjust the scope of a few uSound variables and functions
koda
parents:
7010
diff
changeset
|
1020 |
//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
|
1021 |
NewTurnTick:= $FFFFFFFF; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
1022 |
end; |
4 | 1023 |
|
3038 | 1024 |
procedure freeModule; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
1025 |
begin |
3615 | 1026 |
FreeGearsList(); |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
1027 |
end; |
4 | 1028 |
|
2451
5affd0840927
New data files from Tiy, add gtFlame to avoidance list
nemo
parents:
2428
diff
changeset
|
1029 |
end. |