author | koda |
Fri, 05 Apr 2013 22:57:31 +0200 | |
changeset 8874 | 8121ce2b0a88 |
parent 8632 | b5ed76d2a1f9 |
child 8817 | 0d3014097240 |
child 8833 | c13ebed437cb |
child 9080 | 9b42757d7e71 |
permissions | -rw-r--r-- |
4 | 1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
6700 | 3 |
* Copyright (c) 2004-2012 Andrey Korotaev <unC0Rr@gmail.com> |
4 | 4 |
* |
183 | 5 |
* This program is free software; you can redistribute it and/or modify |
6 |
* it under the terms of the GNU General Public License as published by |
|
7 |
* the Free Software Foundation; version 2 of the License |
|
4 | 8 |
* |
183 | 9 |
* This program is distributed in the hope that it will be useful, |
10 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
11 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
12 |
* GNU General Public License for more details. |
|
4 | 13 |
* |
183 | 14 |
* You should have received a copy of the GNU General Public License |
15 |
* along with this program; if not, write to the Free Software |
|
16 |
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA |
|
4 | 17 |
*) |
18 |
||
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 |
7850 | 36 |
uses SDLh, uConsts, uFloat, uTypes; |
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; |
6515
74a04089bb56
Suggestion of sheepluva's - disable timebox in crates after SD, and set to disabled in Ammo. Also disable switch hedgehog for teams of 1 hedgehog in size, and try and correct what appears to be a bug in reserved hats.
nemo
parents:
6472
diff
changeset
|
42 |
function GetAmmo(Hedgehog: PHedgehog): TAmmoType; |
74a04089bb56
Suggestion of sheepluva's - disable timebox in crates after SD, and set to disabled in Ammo. Also disable switch hedgehog for teams of 1 hedgehog in size, and try and correct what appears to be a bug in reserved hats.
nemo
parents:
6472
diff
changeset
|
43 |
function GetUtility(Hedgehog: PHedgehog): TAmmoType; |
5812 | 44 |
procedure HideHog(HH: PHedgehog); |
45 |
procedure RestoreHog(HH: PHedgehog); |
|
4 | 46 |
procedure ProcessGears; |
3396
e5b3e5f2818e
More portal changes. Allows for a multishoot utility. Hopefully not breaking anything.
nemo
parents:
3390
diff
changeset
|
47 |
procedure EndTurnCleanup; |
4 | 48 |
procedure SetAllToActive; |
8576
286ebfcb3d97
workaround for frequent AllHH active call in hedgehog step
nemo
parents:
8574
diff
changeset
|
49 |
procedure SetAllHHToActive; inline; |
286ebfcb3d97
workaround for frequent AllHH active call in hedgehog step
nemo
parents:
8574
diff
changeset
|
50 |
procedure SetAllHHToActive(Ice: boolean); |
956 | 51 |
procedure DrawGears; |
4 | 52 |
procedure FreeGearsList; |
10 | 53 |
procedure AddMiscGears; |
4 | 54 |
procedure AssignHHCoords; |
3405 | 55 |
function GearByUID(uid : Longword) : PGear; |
6543 | 56 |
procedure doStepDrowningGear(Gear: PGear); |
4385 | 57 |
|
4 | 58 |
|
59 |
implementation |
|
8425
4f226963faef
restored ios project file, updated Game() interface, tweaked arg parsing, updated log writing, minor warnings
koda
parents:
8351
diff
changeset
|
60 |
uses uStore, uSound, uTeams, uRandom, uCollisions, uIO, uLandGraphics, {$IFDEF SDL13}uTouch,{$ENDIF} |
8204 | 61 |
uLocale, uAI, uAmmos, uStats, uVisualGears, uScript, GLunit, uVariables, |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
62 |
uCommands, uUtils, uTextures, uRenderUtils, uGearsRender, uCaptions, uDebug, uLandTexture, |
7592 | 63 |
uGearsHedgehog, uGearsUtils, uGearsList, uGearsHandlers, uGearsHandlersRope; |
789 | 64 |
|
7028 | 65 |
var skipFlag: boolean; |
3697 | 66 |
|
371 | 67 |
procedure AmmoShove(Ammo: PGear; Damage, Power: LongInt); forward; |
1433 | 68 |
//procedure AmmoFlameWork(Ammo: PGear); forward; |
7335 | 69 |
function GearsNear(X, Y: hwFloat; Kind: TGearType; r: LongInt): PGearArrayS; forward; |
15 | 70 |
procedure SpawnBoxOfSmth; forward; |
506 | 71 |
procedure ShotgunShot(Gear: PGear); forward; |
2941
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2940
diff
changeset
|
72 |
procedure doStepCase(Gear: PGear); forward; |
1964 | 73 |
|
6982 | 74 |
|
75 |
var delay: LongWord; |
|
76 |
delay2: LongWord; |
|
77 |
step: (stDelay, stChDmg, stSweep, stTurnReact, |
|
78 |
stAfterDelay, stChWin, stWater, stChWin2, stHealth, |
|
79 |
stSpawn, stNTurn); |
|
80 |
upd: Longword; |
|
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
|
81 |
snowLeft,snowRight: LongInt; |
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
|
82 |
NewTurnTick: LongWord; |
7021
0c75512a8920
adjust the scope of a few uSound variables and functions
koda
parents:
7010
diff
changeset
|
83 |
//SDMusic: shortstring; |
6982 | 84 |
|
5121
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
85 |
// For better maintainability the step handlers of gears are stored in |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
86 |
// separate files. |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
87 |
// Note: step handlers of gears that are hedgehogs are in a different file |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5063
diff
changeset
|
88 |
// than the handlers for all other gears. |
2599 | 89 |
{$INCLUDE "GSHandlers.inc"} |
4 | 90 |
|
91 |
function CheckNoDamage: boolean; // returns TRUE in case of no damaged hhs |
|
92 |
var Gear: PGear; |
|
1849 | 93 |
dmg: LongInt; |
4 | 94 |
begin |
351 | 95 |
CheckNoDamage:= true; |
4 | 96 |
Gear:= GearsList; |
97 |
while Gear <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
98 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
99 |
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
|
100 |
and (Gear^.dY.QWordValue < _0_000004.QWordValue))) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
101 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
102 |
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
|
103 |
inc(Gear^.Damage, Gear^.Karma); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
104 |
if (Gear^.Damage <> 0) and (not Gear^.Invulnerable) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
105 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
106 |
CheckNoDamage:= false; |
4824 | 107 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
108 |
dmg:= Gear^.Damage; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
109 |
if Gear^.Health < dmg then |
3453 | 110 |
begin |
111 |
Gear^.Active:= true; |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
112 |
Gear^.Health:= 0 |
3453 | 113 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
114 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
115 |
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
|
116 |
(* |
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
|
117 |
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
|
118 |
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
|
119 |
and (not Gear^.Hedgehog^.King) and (Gear^.Hedgehog^.Effects[hePoisoned] = 0) and (not SuddenDeathDmg) then |
2017 | 120 |
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
|
121 |
*) |
2017 | 122 |
|
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
|
123 |
spawnHealthTagForHH(Gear, dmg); |
867 | 124 |
|
4365 | 125 |
RenderHealth(Gear^.Hedgehog^); |
126 |
RecountTeamHealth(Gear^.Hedgehog^.Team); |
|
1505 | 127 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
128 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
129 |
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
|
130 |
Gear^.Karma:= 0; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
131 |
Gear^.Damage:= 0 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
132 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
133 |
Gear:= Gear^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
134 |
end; |
4 | 135 |
end; |
136 |
||
1054 | 137 |
procedure HealthMachine; |
138 |
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
|
139 |
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
|
140 |
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
|
141 |
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
|
142 |
tmp: LongWord; |
1054 | 143 |
begin |
3682 | 144 |
Gear:= GearsList; |
1054 | 145 |
|
3682 | 146 |
while Gear <> nil do |
147 |
begin |
|
148 |
if Gear^.Kind = gtHedgehog then |
|
149 |
begin |
|
150 |
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
|
151 |
if Gear^.Hedgehog^.Effects[hePoisoned] <> 0 then |
4111 | 152 |
begin |
3908
1429c303858d
Can't use cHealthDecrease here for these two 'cause it isn't a generic "do some damage to hog" flag, but is rather set when SD starts
nemo
parents:
3894
diff
changeset
|
153 |
inc(tmp, ModifyDamage(5, Gear)); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
154 |
if (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
|
155 |
dec(Gear^.Hedgehog^.InitialHealth) // does not need a minimum check since <= 1 basically disables it |
4111 | 156 |
end; |
4153
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
157 |
if (TotalRounds > cSuddenDTurns - 1) then |
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
158 |
begin |
6bd94e4c5d65
2 more variables to control water rise and health loss during sudden death.
henek
parents:
4148
diff
changeset
|
159 |
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
|
160 |
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
|
161 |
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
|
162 |
end; |
4365 | 163 |
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
|
164 |
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
|
165 |
flag:= false; |
4365 | 166 |
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
|
167 |
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
|
168 |
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
|
169 |
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
|
170 |
flag:= true; |
4111 | 171 |
if not flag then |
172 |
begin |
|
173 |
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
|
174 |
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
|
175 |
dec(Gear^.Hedgehog^.InitialHealth, 5) |
4111 | 176 |
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
|
177 |
end; |
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
|
178 |
if tmp > 0 then |
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
|
179 |
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
|
180 |
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
|
181 |
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
|
182 |
end |
3682 | 183 |
end; |
1054 | 184 |
|
3682 | 185 |
Gear:= Gear^.NextGear |
186 |
end; |
|
1054 | 187 |
end; |
188 |
||
4 | 189 |
procedure ProcessGears; |
7395 | 190 |
var t: PGear; |
4207
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
191 |
i, AliveCount: LongInt; |
3331 | 192 |
s: shortstring; |
4 | 193 |
begin |
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
|
194 |
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
|
195 |
if GameTicks mod 20 = 0 then ScriptCall('onGameTick20'); |
8351 | 196 |
if GameTicks = NewTurnTick then |
197 |
begin |
|
198 |
ScriptCall('onNewTurn'); |
|
199 |
{$IFDEF SDL13} |
|
200 |
uTouch.NewTurnBeginning(); |
|
201 |
{$ENDIF} |
|
202 |
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
|
203 |
|
868 | 204 |
PrvInactive:= AllInactive; |
4 | 205 |
AllInactive:= true; |
1495 | 206 |
|
2940 | 207 |
if (StepSoundTimer > 0) and (StepSoundChannel < 0) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
208 |
StepSoundChannel:= LoopSound(sndSteps) |
2940 | 209 |
else if (StepSoundTimer = 0) and (StepSoundChannel > -1) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
210 |
begin |
7053 | 211 |
StopSoundChan(StepSoundChannel); |
2993
d83edb74e92d
Remove animation on jumping/resuming walk, only leave it in on weapon switch
nemo
parents:
2991
diff
changeset
|
212 |
StepSoundChannel:= -1 |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
213 |
end; |
2940 | 214 |
|
215 |
if StepSoundTimer > 0 then |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
216 |
dec(StepSoundTimer, 1); |
2940 | 217 |
|
4 | 218 |
t:= GearsList; |
1054 | 219 |
while t <> nil do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
220 |
begin |
7395 | 221 |
curHandledGear:= t; |
222 |
t:= curHandledGear^.NextGear; |
|
3123 | 223 |
|
7517 | 224 |
if curHandledGear^.Message and gmDelete <> 0 then |
7519 | 225 |
DeleteGear(curHandledGear) |
226 |
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
|
227 |
begin |
7519 | 228 |
if curHandledGear^.Message and gmRemoveFromList <> 0 then |
229 |
begin |
|
230 |
RemoveGearFromList(curHandledGear); |
|
231 |
// 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 |
|
232 |
if curHandledGear^.Message and gmAddToList <> 0 then InsertGearToList(curHandledGear); |
|
233 |
curHandledGear^.Message:= curHandledGear^.Message and (not (gmRemoveFromList or gmAddToList)) |
|
234 |
end; |
|
235 |
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
|
236 |
begin |
7519 | 237 |
if curHandledGear^.RenderTimer and (curHandledGear^.Timer > 500) and ((curHandledGear^.Timer mod 1000) = 0) then |
238 |
begin |
|
239 |
FreeTexture(curHandledGear^.Tex); |
|
240 |
curHandledGear^.Tex:= RenderStringTex(inttostr(curHandledGear^.Timer div 1000), cWhiteColor, fntSmall); |
|
241 |
end; |
|
242 |
curHandledGear^.doStep(curHandledGear); |
|
243 |
// might be useful later |
|
244 |
//ScriptCall('onGearStep', Gear^.uid); |
|
245 |
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
|
246 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
247 |
end; |
7395 | 248 |
curHandledGear:= nil; |
89 | 249 |
|
4 | 250 |
if AllInactive then |
1343 | 251 |
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
|
252 |
stDelay: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
253 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
254 |
if delay = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
255 |
delay:= cInactDelay |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
256 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
257 |
dec(delay); |
614 | 258 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
259 |
if delay = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
260 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
261 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
262 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
263 |
stChDmg: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
264 |
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
|
265 |
inc(step) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
266 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
267 |
step:= stDelay; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
268 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
269 |
stSweep: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
270 |
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
|
271 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
272 |
SetAllToActive; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
273 |
step:= stChDmg |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
274 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
275 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
276 |
inc(step); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
277 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
278 |
stTurnReact: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
279 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
280 |
if (not bBetweenTurns) and (not isInMultiShoot) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
281 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
282 |
uStats.TurnReaction; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
283 |
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
|
284 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
285 |
else |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
286 |
inc(step, 2); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
287 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
288 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
289 |
stAfterDelay: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
290 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
291 |
if delay = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
292 |
delay:= cInactDelay |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
293 |
else |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
294 |
dec(delay); |
815 | 295 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
296 |
if delay = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
297 |
inc(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
298 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
299 |
stChWin: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
300 |
begin |
7669
a85e1c167b69
I didn't want to do this since it seems less clean, but...
sheepluva
parents:
7667
diff
changeset
|
301 |
CheckForWin(); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
302 |
inc(step) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
303 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
304 |
stWater: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
305 |
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
|
306 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
307 |
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
|
308 |
bWaterRising:= true; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
309 |
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
|
310 |
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
|
311 |
inc(step) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
312 |
end |
7667
4346566c5a58
skip second CheckForWin if water wasn't raised after first one
sheepluva
parents:
7666
diff
changeset
|
313 |
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
|
314 |
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
|
315 |
stChWin2: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
316 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
317 |
CheckForWin; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
318 |
inc(step) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
319 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
320 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
321 |
stHealth: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
322 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
323 |
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
|
324 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
325 |
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
|
326 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
327 |
SuddenDeath:= true; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
328 |
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
|
329 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
330 |
SuddenDeathDmg:= true; |
5558
49cfd05ccb83
new SD flakes from mikade and a flash when sudden death starts
Henek
parents:
5556
diff
changeset
|
331 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
332 |
// flash |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
333 |
ScreenFade:= sfFromWhite; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
334 |
ScreenFadeValue:= sfMax; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
335 |
ScreenFadeSpeed:= 1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
336 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
337 |
ChangeToSDClouds; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
338 |
ChangeToSDFlakes; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
339 |
glClearColor(SDSkyColor.r * (SDTint/255) / 255, SDSkyColor.g * (SDTint/255) / 255, SDSkyColor.b * (SDTint/255) / 255, 0.99); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
340 |
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
|
341 |
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
|
342 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
343 |
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
|
344 |
playSound(sndSuddenDeath); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
345 |
StopMusic //No SDMusic for now |
7021
0c75512a8920
adjust the scope of a few uSound variables and functions
koda
parents:
7010
diff
changeset
|
346 |
//ChangeMusic(SDMusic) |
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
|
347 |
end |
6453
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6380
diff
changeset
|
348 |
else if (TotalRounds < cSuddenDTurns) and (not isInMultiShoot) 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
|
349 |
begin |
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
|
350 |
i:= cSuddenDTurns - TotalRounds; |
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
|
351 |
s:= inttostr(i); |
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
|
352 |
if i = 1 then |
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
|
353 |
AddCaption(trmsg[sidRoundSD], cWhiteColor, capgrpGameState) |
6453
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6380
diff
changeset
|
354 |
else if (i = 2) or ((i > 0) and ((i mod 50 = 0) or ((i <= 25) and (i mod 5 = 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
|
355 |
AddCaption(Format(trmsg[sidRoundsSD], s), cWhiteColor, capgrpGameState); |
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
|
356 |
end; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
357 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
358 |
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
|
359 |
or isInMultiShoot |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
360 |
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
|
361 |
inc(step) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
362 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
363 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
364 |
bBetweenTurns:= true; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
365 |
HealthMachine; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
366 |
step:= stChDmg |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
367 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
368 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
369 |
stSpawn: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
370 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
371 |
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
|
372 |
SpawnBoxOfSmth; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
373 |
inc(step) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
374 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
375 |
stNTurn: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
376 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
377 |
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
|
378 |
isInMultiShoot:= false |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
379 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
380 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
381 |
// 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
|
382 |
// 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
|
383 |
//ZoomValue:= ZoomDefault; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
384 |
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
|
385 |
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
|
386 |
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
|
387 |
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
|
388 |
OnUsedAmmo(CurrentHedgehog^); |
3697 | 389 |
|
3396
e5b3e5f2818e
More portal changes. Allows for a multishoot utility. Hopefully not breaking anything.
nemo
parents:
3390
diff
changeset
|
390 |
EndTurnCleanup; |
2376 | 391 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
392 |
FreeActionsList; // could send -left, -right and similar commands, so should be called before /nextturn |
1298 | 393 |
|
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
|
394 |
ParseCommand('/nextturn', true); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
395 |
SwitchHedgehog; |
1298 | 396 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
397 |
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
|
398 |
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
|
399 |
NewTurnTick:= GameTicks + 1 |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
400 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
401 |
step:= Low(step) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
402 |
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
|
403 |
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
|
404 |
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
|
405 |
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
|
406 |
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
|
407 |
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
|
408 |
else |
3957 | 409 |
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
|
410 |
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
|
411 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
412 |
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
|
413 |
and (not CurrentHedgehog^.Unplaced) then |
5507
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5501
diff
changeset
|
414 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
415 |
if (CurrentHedgehog^.Gear^.State and gstAttacked <> 0) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
416 |
and (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
|
417 |
begin |
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5501
diff
changeset
|
418 |
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
|
419 |
isCursorVisible := true |
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5501
diff
changeset
|
420 |
end; |
6453
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6380
diff
changeset
|
421 |
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
|
422 |
end; |
3957 | 423 |
if delay2 = 0 then |
424 |
begin |
|
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) 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
|
426 |
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
|
427 |
SweepDirty; |
3957 | 428 |
CheckNoDamage; |
4207
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
429 |
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
|
430 |
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
|
431 |
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
|
432 |
inc(AliveCount); |
4207
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
433 |
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
|
434 |
begin |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
435 |
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
|
436 |
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
|
437 |
TagTurnTimeLeft:= TurnTimeLeft; |
4207
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
438 |
TurnTimeLeft:= 0 |
31e77dcf18fe
better end of turn in infinite attack mode. NEEDS TESTING.
nemo
parents:
4198
diff
changeset
|
439 |
end |
3957 | 440 |
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
|
441 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
442 |
end; |
15 | 443 |
|
4 | 444 |
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
|
445 |
if CurrentHedgehog^.Gear <> nil then |
8562
d9d1cb650ff8
Restore freezing hedgehog for shotgun, sniper rifle and deagle to make unc0rr happy. You'll still be able to get away after throwing cleaver and sticky bomb tho.
nemo
parents:
8492
diff
changeset
|
446 |
if ((CurrentHedgehog^.Gear^.State and gstAttacking) = 0) and |
d9d1cb650ff8
Restore freezing hedgehog for shotgun, sniper rifle and deagle to make unc0rr happy. You'll still be able to get away after throwing cleaver and sticky bomb tho.
nemo
parents:
8492
diff
changeset
|
447 |
not(isInMultiShoot and (CurrentHedgehog^.CurAmmoType in [amShotgun, amDEagle, amSniperRifle])) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
448 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
449 |
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
|
450 |
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
|
451 |
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
|
452 |
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
|
453 |
and ((CurrentHedgehog^.Gear^.State and gstAttacked) = 0) then |
7053 | 454 |
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
|
455 |
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
|
456 |
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
|
457 |
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
|
458 |
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
|
459 |
dec(ReadyTimeLeft) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
460 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
461 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
462 |
dec(TurnTimeLeft) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
463 |
end; |
351 | 464 |
|
2621
956ff066f3a5
Fix desync when playing with AI via network, occuring in certain conditions
unc0rr
parents:
2619
diff
changeset
|
465 |
if skipFlag then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
466 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
467 |
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
|
468 |
TagTurnTimeLeft:= TurnTimeLeft; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
469 |
TurnTimeLeft:= 0; |
3784
75aa91bea32b
Extend statistics collection (TeamKills, TurnSkips, TeamDamage)
burp
parents:
3775
diff
changeset
|
470 |
skipFlag:= false; |
75aa91bea32b
Extend statistics collection (TeamKills, TurnSkips, TeamDamage)
burp
parents:
3775
diff
changeset
|
471 |
inc(CurrentHedgehog^.Team^.stats.TurnSkips); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
472 |
end; |
2621
956ff066f3a5
Fix desync when playing with AI via network, occuring in certain conditions
unc0rr
parents:
2619
diff
changeset
|
473 |
|
2134 | 474 |
if ((GameTicks and $FFFF) = $FFFF) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
475 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
476 |
if (not CurrentTeam^.ExtDriven) then |
5810 | 477 |
begin |
7068 | 478 |
SendIPC(_S'#'); |
5810 | 479 |
AddFileLog('hiTicks increment message sent') |
480 |
end; |
|
2134 | 481 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
482 |
if (not CurrentTeam^.ExtDriven) or CurrentTeam^.hasGone then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
483 |
inc(hiTicks) // we do not recieve a message for this |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
484 |
end; |
7407 | 485 |
AddRandomness(CheckSum); |
7988 | 486 |
|
515 | 487 |
inc(GameTicks) |
4 | 488 |
end; |
489 |
||
3396
e5b3e5f2818e
More portal changes. Allows for a multishoot utility. Hopefully not breaking anything.
nemo
parents:
3390
diff
changeset
|
490 |
//Purpose, to reset all transient attributes toggled by a utility and clean up various gears and effects at end of turn |
1854 | 491 |
//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
|
492 |
procedure EndTurnCleanup; |
1865
ebc6dfca60d4
- nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1863
diff
changeset
|
493 |
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
|
494 |
t: PGear; |
1849 | 495 |
begin |
2221 | 496 |
SpeechText:= ''; // in case it has not been consumed |
2017 | 497 |
|
1895 | 498 |
if (GameFlags and gfLowGravity) = 0 then |
4623 | 499 |
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
|
500 |
cGravity:= cMaxWindSpeed * 2; |
4623 | 501 |
cGravityf:= 0.00025 * 2 |
502 |
end; |
|
1895 | 503 |
|
2017 | 504 |
if (GameFlags and gfVampiric) = 0 then |
505 |
cVampiric:= false; |
|
506 |
||
1849 | 507 |
cDamageModifier:= _1; |
1895 | 508 |
|
509 |
if (GameFlags and gfLaserSight) = 0 then |
|
510 |
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
|
511 |
|
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
512 |
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
|
513 |
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
|
514 |
// 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
|
515 |
if (CurrentTeam <> nil) then |
4099 | 516 |
with CurrentTeam^ do |
517 |
for i:= 0 to cMaxHHIndex do |
|
518 |
with Hedgehogs[i] do |
|
519 |
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
|
520 |
(* |
4099 | 521 |
if (SpeechGear <> nil) then |
522 |
begin |
|
523 |
DeleteVisualGear(SpeechGear); // remove to restore persisting beyond end of turn. Tiy says was too much of a gameplay issue |
|
524 |
SpeechGear:= nil |
|
525 |
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
|
526 |
*) |
2045
b0588498bc3a
- Fix network (my crappy fault, triggered by nemo's patch)
unc0rr
parents:
2042
diff
changeset
|
527 |
|
4099 | 528 |
if (Gear <> nil) then |
529 |
begin |
|
530 |
if (GameFlags and gfInvulnerable) = 0 then |
|
531 |
Gear^.Invulnerable:= false; |
|
532 |
end; |
|
533 |
end; |
|
3480
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
534 |
t:= GearsList; |
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
535 |
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
|
536 |
begin |
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
537 |
t^.PortalCounter:= 0; |
4372 | 538 |
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
|
539 |
begin |
4372 | 540 |
t^.Health:= t^.Hedgehog^.InitialHealth; |
541 |
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
|
542 |
end; |
3480
c4c3f3512404
Prevent all portal loops the guaranteed way, at least until sheepluva's tests yield something reliable.
nemo
parents:
3476
diff
changeset
|
543 |
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
|
544 |
end; |
41e06b74c991
Enable resetting of weapons after each turn - useful in combination with a limited weaponset and unlimited attacks
nemo
parents:
3908
diff
changeset
|
545 |
|
6453
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6380
diff
changeset
|
546 |
if ((GameFlags and gfResetWeps) <> 0) and (not PlacingHogs) then |
4099 | 547 |
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
|
548 |
|
4099 | 549 |
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
|
550 |
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
|
551 |
RecountTeamHealth(TeamsArray[i]) |
1849 | 552 |
end; |
2045
b0588498bc3a
- Fix network (my crappy fault, triggered by nemo's patch)
unc0rr
parents:
2042
diff
changeset
|
553 |
|
4 | 554 |
procedure SetAllToActive; |
555 |
var t: PGear; |
|
556 |
begin |
|
557 |
AllInactive:= false; |
|
558 |
t:= GearsList; |
|
351 | 559 |
while t <> nil do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
560 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
561 |
t^.Active:= true; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
562 |
t:= t^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
563 |
end |
4 | 564 |
end; |
565 |
||
8576
286ebfcb3d97
workaround for frequent AllHH active call in hedgehog step
nemo
parents:
8574
diff
changeset
|
566 |
procedure SetAllHHToActive; inline; |
286ebfcb3d97
workaround for frequent AllHH active call in hedgehog step
nemo
parents:
8574
diff
changeset
|
567 |
begin |
286ebfcb3d97
workaround for frequent AllHH active call in hedgehog step
nemo
parents:
8574
diff
changeset
|
568 |
SetAllHHToActive(true) |
286ebfcb3d97
workaround for frequent AllHH active call in hedgehog step
nemo
parents:
8574
diff
changeset
|
569 |
end; |
286ebfcb3d97
workaround for frequent AllHH active call in hedgehog step
nemo
parents:
8574
diff
changeset
|
570 |
|
286ebfcb3d97
workaround for frequent AllHH active call in hedgehog step
nemo
parents:
8574
diff
changeset
|
571 |
procedure SetAllHHToActive(Ice: boolean); |
4 | 572 |
var t: PGear; |
573 |
begin |
|
574 |
AllInactive:= false; |
|
575 |
t:= GearsList; |
|
351 | 576 |
while t <> nil do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
577 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
578 |
if (t^.Kind = gtHedgehog) or (t^.Kind = gtExplosives) then |
8574 | 579 |
begin |
8576
286ebfcb3d97
workaround for frequent AllHH active call in hedgehog step
nemo
parents:
8574
diff
changeset
|
580 |
if (t^.Kind = gtHedgehog) and Ice then CheckIce(t); |
8574 | 581 |
t^.Active:= true |
582 |
end; |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
583 |
t:= t^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
584 |
end |
4 | 585 |
end; |
586 |
||
4385 | 587 |
procedure DrawGears; |
588 |
var Gear: PGear; |
|
589 |
x, y: LongInt; |
|
2802 | 590 |
begin |
4385 | 591 |
Gear:= GearsList; |
592 |
while Gear <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
593 |
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
|
594 |
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
|
595 |
begin |
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset
|
596 |
x:= hwRound(Gear^.X) + WorldDx; |
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset
|
597 |
y:= hwRound(Gear^.Y) + WorldDy; |
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset
|
598 |
RenderGear(Gear, x, y); |
0bc81de36e08
Don't draw snow flakes spawned in land, introduce gstInvisible flag
unc0rr
parents:
5319
diff
changeset
|
599 |
end; |
4385 | 600 |
Gear:= Gear^.NextGear |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
601 |
end; |
2802 | 602 |
end; |
603 |
||
4 | 604 |
procedure FreeGearsList; |
605 |
var t, tt: PGear; |
|
606 |
begin |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
607 |
tt:= GearsList; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
608 |
GearsList:= nil; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
609 |
while tt <> nil do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
610 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
611 |
t:= tt; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
612 |
tt:= tt^.NextGear; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
613 |
Dispose(t) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
614 |
end; |
4 | 615 |
end; |
616 |
||
10 | 617 |
procedure AddMiscGears; |
7406
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset
|
618 |
var i,rx, ry: Longword; |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset
|
619 |
rdx, rdy: hwFloat; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
620 |
Gear: PGear; |
4 | 621 |
begin |
498 | 622 |
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
|
623 |
|
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
|
624 |
i:= 0; |
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
|
625 |
Gear:= PGear(1); |
4834 | 626 |
while (i < cLandMines) {and (Gear <> nil)} do // disable this check until better solution found |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
627 |
begin |
4148
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
628 |
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
|
629 |
FindPlace(Gear, false, 0, LAND_WIDTH); |
4830
c5ddc3e6c8a4
Don't waste CPU cycles trying to find a piece of land when there's no free land left
unc0rr
parents:
4826
diff
changeset
|
630 |
inc(i) |
4148
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
631 |
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
|
632 |
|
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
|
633 |
i:= 0; |
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
|
634 |
Gear:= PGear(1); |
4833 | 635 |
while (i < cExplosives){ and (Gear <> nil)} do |
4148
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
636 |
begin |
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
637 |
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
|
638 |
FindPlace(Gear, false, 0, LAND_WIDTH); |
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
|
639 |
inc(i) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
640 |
end; |
1895 | 641 |
|
642 |
if (GameFlags and gfLowGravity) <> 0 then |
|
4623 | 643 |
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
|
644 |
cGravity:= cMaxWindSpeed; |
4623 | 645 |
cGravityf:= 0.00025 |
646 |
end; |
|
1895 | 647 |
|
2017 | 648 |
if (GameFlags and gfVampiric) <> 0 then |
649 |
cVampiric:= true; |
|
650 |
||
1895 | 651 |
Gear:= GearsList; |
652 |
if (GameFlags and gfInvulnerable) <> 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
|
653 |
while Gear <> nil do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
654 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
655 |
Gear^.Invulnerable:= true; // this is only checked on hogs right now, so no need for gear type check |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
656 |
Gear:= Gear^.NextGear |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
657 |
end; |
1895 | 658 |
|
659 |
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
|
660 |
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
|
661 |
|
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2020
diff
changeset
|
662 |
if (GameFlags and gfArtillery) <> 0 then |
4611 | 663 |
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
|
664 |
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
|
665 |
begin |
f415b3e0f3b9
Burn a random number in the override. Make sure cirbuf is reset.
nemo
parents:
7519
diff
changeset
|
666 |
rx:= GetRandom(rightX-leftX)+leftX; |
7406
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset
|
667 |
ry:= GetRandom(LAND_HEIGHT-topY)+topY; |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset
|
668 |
rdx:= _90-(GetRandomf*_360); |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset
|
669 |
rdy:= _90-(GetRandomf*_360); |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset
|
670 |
AddGear(rx, ry, gtGenericFaller, gstInvisible, rdx, rdy, $FFFFFFFF); |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset
|
671 |
end; |
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7400
diff
changeset
|
672 |
|
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
|
673 |
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
|
674 |
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
|
675 |
|
7767 | 676 |
if (not hasBorder) and ((Theme = 'Snow') or (Theme = 'Christmas')) then |
7721 | 677 |
for i:= vobCount * Longword(max(LAND_WIDTH,4096)) div 2048 downto 1 do |
8003 | 678 |
AddGear(LongInt(GetRandom(snowRight - snowLeft)) + snowLeft, LAND_HEIGHT + LongInt(GetRandom(750)) - 1300, gtFlake, 0, _0, _0, 0); |
4 | 679 |
end; |
680 |
||
681 |
||
506 | 682 |
procedure ShotgunShot(Gear: PGear); |
683 |
var t: PGear; |
|
5586
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
684 |
dmg, r, dist: LongInt; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
685 |
dx, dy: hwFloat; |
506 | 686 |
begin |
509 | 687 |
Gear^.Radius:= cShotgunRadius; |
506 | 688 |
t:= GearsList; |
689 |
while t <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
690 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
691 |
case t^.Kind of |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
692 |
gtHedgehog, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
693 |
gtMine, |
3710 | 694 |
gtSMine, |
7755
b8958e64e68d
Also shove using shotgun, switch off hat when not active hog
nemo
parents:
7754
diff
changeset
|
695 |
gtKnife, |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
696 |
gtCase, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
697 |
gtTarget, |
8161 | 698 |
gtExplosives: begin//, |
699 |
// gtStructure: begin |
|
5586
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
700 |
//addFileLog('ShotgunShot radius: ' + inttostr(Gear^.Radius) + ', t^.Radius = ' + inttostr(t^.Radius) + ', distance = ' + inttostr(dist) + ', dmg = ' + inttostr(dmg)); |
5590 | 701 |
dmg:= 0; |
5586
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
702 |
r:= Gear^.Radius + t^.Radius; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
703 |
dx:= Gear^.X-t^.X; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
704 |
dx.isNegative:= false; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
705 |
dy:= Gear^.Y-t^.Y; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
706 |
dy.isNegative:= false; |
5590 | 707 |
if r-hwRound(dx+dy) > 0 then |
5586
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
708 |
begin |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
709 |
dist:= hwRound(Distance(dx, dy)); |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
710 |
dmg:= ModifyDamage(min(r - dist, 25), t); |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
711 |
end; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
712 |
if dmg > 0 then |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
713 |
begin |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
714 |
if (not t^.Invulnerable) then |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
715 |
ApplyDamage(t, Gear^.Hedgehog, dmg, dsBullet) |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
716 |
else |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
717 |
Gear^.State:= Gear^.State or gstWinner; |
867 | 718 |
|
5586
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
719 |
DeleteCI(t); |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
720 |
t^.dX:= t^.dX + Gear^.dX * dmg * _0_01 + SignAs(cHHKick, Gear^.dX); |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
721 |
t^.dY:= t^.dY + Gear^.dY * dmg * _0_01; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
722 |
t^.State:= t^.State or gstMoving; |
7767 | 723 |
if t^.Kind = gtKnife then t^.State:= t^.State and (not gstCollision); |
5586
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
724 |
t^.Active:= true; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
725 |
FollowGear:= t |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
726 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
727 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
728 |
gtGrave: begin |
5590 | 729 |
dmg:= 0; |
5586
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
730 |
r:= Gear^.Radius + t^.Radius; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
731 |
dx:= Gear^.X-t^.X; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
732 |
dx.isNegative:= false; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
733 |
dy:= Gear^.Y-t^.Y; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
734 |
dy.isNegative:= false; |
5590 | 735 |
if r-hwRound(dx+dy) > 0 then |
5586
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
736 |
begin |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
737 |
dist:= hwRound(Distance(dx, dy)); |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
738 |
dmg:= ModifyDamage(min(r - dist, 25), t); |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
739 |
end; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
740 |
if dmg > 0 then |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
741 |
begin |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
742 |
t^.dY:= - _0_1; |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
743 |
t^.Active:= true |
3bb02b92df7d
Add square check to shotgun. This a minor optimisation that might sidestep a bug on iOS/Android. Still need to find out why the bug is happening though
nemo
parents:
5584
diff
changeset
|
744 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
745 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
746 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
747 |
t:= t^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
748 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
749 |
if (GameFlags and gfSolidLand) = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
750 |
DrawExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), cShotgunRadius) |
506 | 751 |
end; |
752 |
||
371 | 753 |
procedure AmmoShove(Ammo: PGear; Damage, Power: LongInt); |
53 | 754 |
var t: PGearArray; |
2424
b52344de23ae
In progress, trying to make a fire for molotov cocktail. Normal fire should still work fairly normally.
nemo
parents:
2407
diff
changeset
|
755 |
Gear: PGear; |
7754 | 756 |
i, j, tmpDmg: LongInt; |
4327 | 757 |
VGear: PVisualGear; |
38 | 758 |
begin |
53 | 759 |
t:= CheckGearsCollision(Ammo); |
3098
e5a1bc4e56fd
Specifically check for current hedgehog being on rope, the tricky bastard.
nemo
parents:
3097
diff
changeset
|
760 |
// Just to avoid hogs on rope dodging fire. |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
761 |
if (CurAmmoGear <> nil) and ((CurAmmoGear^.Kind = gtRope) or (CurAmmoGear^.Kind = gtJetpack) or (CurAmmoGear^.Kind = gtBirdy)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
762 |
and (CurrentHedgehog^.Gear <> nil) and (CurrentHedgehog^.Gear^.CollisionIndex = -1) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
763 |
and (sqr(hwRound(Ammo^.X) - hwRound(CurrentHedgehog^.Gear^.X)) + sqr(hwRound(Ammo^.Y) - hwRound(CurrentHedgehog^.Gear^.Y)) <= sqr(cHHRadius + Ammo^.Radius)) then |
3098
e5a1bc4e56fd
Specifically check for current hedgehog being on rope, the tricky bastard.
nemo
parents:
3097
diff
changeset
|
764 |
begin |
e5a1bc4e56fd
Specifically check for current hedgehog being on rope, the tricky bastard.
nemo
parents:
3097
diff
changeset
|
765 |
t^.ar[t^.Count]:= CurrentHedgehog^.Gear; |
e5a1bc4e56fd
Specifically check for current hedgehog being on rope, the tricky bastard.
nemo
parents:
3097
diff
changeset
|
766 |
inc(t^.Count) |
4182 | 767 |
end; |
4165 | 768 |
|
351 | 769 |
i:= t^.Count; |
1506 | 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 (Ammo^.Kind = gtFlame) and (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
|
772 |
Ammo^.Health:= 0; |
53 | 773 |
while i > 0 do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
774 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
775 |
dec(i); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
776 |
Gear:= t^.ar[i]; |
8563
4d9d8287e601
Trying to improve rendering, sliding and thawing. Messing around w/ making fire thaw faster.
nemo
parents:
8492
diff
changeset
|
777 |
if (Ammo^.Kind = gtFlame) and (Gear^.Kind = gtHedgehog) and (Gear^.Hedgehog^.Effects[heFrozen] > 255) then |
4d9d8287e601
Trying to improve rendering, sliding and thawing. Messing around w/ making fire thaw faster.
nemo
parents:
8492
diff
changeset
|
778 |
Gear^.Hedgehog^.Effects[heFrozen]:= max(255,Gear^.Hedgehog^.Effects[heFrozen]-10000); |
2726 | 779 |
tmpDmg:= ModifyDamage(Damage, Gear); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
780 |
if (Gear^.State and gstNoDamage) = 0 then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
781 |
begin |
4824 | 782 |
|
4329 | 783 |
if (Ammo^.Kind = gtDEagleShot) or (Ammo^.Kind = gtSniperRifleShot) then |
4578 | 784 |
begin |
4329 | 785 |
VGear := AddVisualGear(hwround(Ammo^.X), hwround(Ammo^.Y), vgtBulletHit); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
786 |
if VGear <> nil then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
787 |
VGear^.Angle := DxDy2Angle(-Ammo^.dX, Ammo^.dY); |
4329 | 788 |
end; |
4824 | 789 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
790 |
if (Gear^.Kind = gtHedgehog) and (Ammo^.State and gsttmpFlag <> 0) and (Ammo^.Kind = gtShover) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
791 |
Gear^.FlightTime:= 1; |
3697 | 792 |
|
8563
4d9d8287e601
Trying to improve rendering, sliding and thawing. Messing around w/ making fire thaw faster.
nemo
parents:
8492
diff
changeset
|
793 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
794 |
case Gear^.Kind of |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
795 |
gtHedgehog, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
796 |
gtMine, |
3710 | 797 |
gtSMine, |
7754 | 798 |
gtKnife, |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
799 |
gtTarget, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
800 |
gtCase, |
8161 | 801 |
gtExplosives: //, |
802 |
//gtStructure: |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
803 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
804 |
if (Ammo^.Kind = gtDrill) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
805 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
806 |
Ammo^.Timer:= 0; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
807 |
exit; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
808 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
809 |
if (not Gear^.Invulnerable) then |
7754 | 810 |
begin |
811 |
if (Ammo^.Kind = gtKnife) and (tmpDmg > 0) then |
|
812 |
for j:= 1 to max(1,min(3,tmpDmg div 5)) do |
|
813 |
begin |
|
814 |
VGear:= AddVisualGear(hwRound(Ammo^.X-((Ammo^.X-Gear^.X)/_2)), hwRound(Ammo^.Y-((Ammo^.Y-Gear^.Y)/_2)), vgtStraightShot); |
|
815 |
if VGear <> nil then |
|
816 |
with VGear^ do |
|
817 |
begin |
|
818 |
Tint:= $FFCC00FF; |
|
819 |
Angle:= random(360); |
|
820 |
dx:= 0.0005 * (random(100)); |
|
821 |
dy:= 0.0005 * (random(100)); |
|
822 |
if random(2) = 0 then |
|
823 |
dx := -dx; |
|
824 |
if random(2) = 0 then |
|
825 |
dy := -dy; |
|
826 |
FrameTicks:= 600+random(200); |
|
827 |
State:= ord(sprStar) |
|
828 |
end |
|
829 |
end; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
830 |
ApplyDamage(Gear, Ammo^.Hedgehog, tmpDmg, dsShove) |
7754 | 831 |
end |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
832 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
833 |
Gear^.State:= Gear^.State or gstWinner; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
834 |
if (Gear^.Kind = gtExplosives) and (Ammo^.Kind = gtBlowtorch) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
835 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
836 |
if (Ammo^.Hedgehog^.Gear <> nil) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
837 |
Ammo^.Hedgehog^.Gear^.State:= Ammo^.Hedgehog^.Gear^.State and (not gstNotKickable); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
838 |
ApplyDamage(Gear, Ammo^.Hedgehog, tmpDmg * 100, dsUnknown); // crank up damage for explosives + blowtorch |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
839 |
end; |
867 | 840 |
|
8632
b5ed76d2a1f9
Make hogs thaw only on enemy turns, make timebox counter decrement only on your turn, adjust knock for frozen hogs, increase damage on frozen hogs, make freezer fuel only reduce when not adjusting angle.
nemo
parents:
8589
diff
changeset
|
841 |
if (Gear^.Kind = gtHedgehog) and (Gear^.Hedgehog^.King or (Gear^.Hedgehog^.Effects[heFrozen] > 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
|
842 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
843 |
Gear^.dX:= Ammo^.dX * Power * _0_005; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
844 |
Gear^.dY:= Ammo^.dY * Power * _0_005 |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
845 |
end |
7761 | 846 |
else if ((Ammo^.Kind <> gtFlame) or (Gear^.Kind = gtHedgehog)) and (Power <> 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
|
847 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
848 |
Gear^.dX:= Ammo^.dX * Power * _0_01; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
849 |
Gear^.dY:= Ammo^.dY * Power * _0_01 |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
850 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
851 |
|
7754 | 852 |
if (not isZero(Gear^.dX)) or (not isZero(Gear^.dY)) then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
853 |
begin |
7754 | 854 |
Gear^.Active:= true; |
855 |
DeleteCI(Gear); |
|
856 |
Gear^.State:= Gear^.State or gstMoving; |
|
7767 | 857 |
if Gear^.Kind = gtKnife then Gear^.State:= Gear^.State and (not gstCollision); |
7754 | 858 |
// move the gear upwards a bit to throw it over tiny obstacles at start |
859 |
if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) then |
|
860 |
begin |
|
861 |
if not (TestCollisionXwithXYShift(Gear, _0, -3, hwSign(Gear^.dX)) |
|
862 |
or (TestCollisionYwithGear(Gear, -1) <> 0)) then |
|
863 |
Gear^.Y:= Gear^.Y - _1; |
|
864 |
if not (TestCollisionXwithXYShift(Gear, _0, -2, hwSign(Gear^.dX)) |
|
865 |
or (TestCollisionYwithGear(Gear, -1) <> 0)) then |
|
866 |
Gear^.Y:= Gear^.Y - _1; |
|
867 |
if not (TestCollisionXwithXYShift(Gear, _0, -1, hwSign(Gear^.dX)) |
|
868 |
or (TestCollisionYwithGear(Gear, -1) <> 0)) then |
|
869 |
Gear^.Y:= Gear^.Y - _1; |
|
870 |
end |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
871 |
end; |
867 | 872 |
|
7754 | 873 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
874 |
if (Ammo^.Kind <> gtFlame) or ((Ammo^.State and gsttmpFlag) = 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
875 |
FollowGear:= Gear |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
876 |
end; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
877 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
878 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
879 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
880 |
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
|
881 |
SetAllToActive |
38 | 882 |
end; |
883 |
||
4 | 884 |
procedure AssignHHCoords; |
955 | 885 |
var i, t, p, j: LongInt; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
886 |
ar: array[0..Pred(cMaxHHs)] of PHedgehog; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
887 |
Count: Longword; |
4 | 888 |
begin |
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 (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
|
890 |
PlacingHogs:= true; |
4148
eaff5615f976
Decouple forts from divide/mines/explosives, since those can be set individually these days
henek
parents:
4143
diff
changeset
|
891 |
if (GameFlags and gfDivideTeams) <> 0 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
892 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
893 |
t:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
894 |
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
|
895 |
for p:= 0 to 1 do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
896 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
897 |
with ClansArray[p]^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
898 |
for j:= 0 to Pred(TeamsNumber) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
899 |
with Teams[j]^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
900 |
for i:= 0 to cMaxHHIndex do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
901 |
with Hedgehogs[i] do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
902 |
if (Gear <> nil) and (Gear^.X.QWordValue = 0) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
903 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
904 |
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
|
905 |
Unplaced:= true |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
906 |
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
|
907 |
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
|
908 |
if Gear <> nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
909 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
910 |
Gear^.Pos:= GetRandom(49); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
911 |
Gear^.dX.isNegative:= p = 1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
912 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
913 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
914 |
t:= LAND_WIDTH div 2 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
915 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
916 |
end else // mix hedgehogs |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
917 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
918 |
Count:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
919 |
for p:= 0 to Pred(TeamsCount) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
920 |
with TeamsArray[p]^ do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
921 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
922 |
for i:= 0 to cMaxHHIndex do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
923 |
with Hedgehogs[i] do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
924 |
if (Gear <> nil) and (Gear^.X.QWordValue = 0) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
925 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
926 |
ar[Count]:= @Hedgehogs[i]; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
927 |
inc(Count) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
928 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
929 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
930 |
while (Count > 0) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
931 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
932 |
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
|
933 |
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
|
934 |
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
|
935 |
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
|
936 |
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
|
937 |
if ar[i]^.Gear <> nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
938 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
939 |
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
|
940 |
ar[i]^.Gear^.Pos:= GetRandom(19) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
941 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
942 |
ar[i]:= ar[Count - 1]; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
943 |
dec(Count) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
944 |
end |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
945 |
end |
4 | 946 |
end; |
947 |
||
7335 | 948 |
var GearsNearArray : TPGearArray; |
949 |
function GearsNear(X, Y: hwFloat; Kind: TGearType; r: LongInt): PGearArrayS; |
|
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
950 |
var |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
951 |
t: PGear; |
7335 | 952 |
s: Longword; |
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
953 |
begin |
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
|
954 |
r:= r*r; |
7335 | 955 |
s:= 0; |
956 |
SetLength(GearsNearArray, s); |
|
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
957 |
t := GearsList; |
5556 | 958 |
while t <> nil do |
959 |
begin |
|
960 |
if (t^.Kind = Kind) |
|
961 |
and ((X - t^.X)*(X - t^.X) + (Y - t^.Y)*(Y-t^.Y) < int2hwFloat(r)) then |
|
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
962 |
begin |
7335 | 963 |
inc(s); |
964 |
SetLength(GearsNearArray, s); |
|
965 |
GearsNearArray[s - 1] := t; |
|
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
966 |
end; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
967 |
t := t^.NextGear; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
968 |
end; |
7335 | 969 |
|
970 |
GearsNear.size:= s; |
|
971 |
GearsNear.ar:= @GearsNearArray |
|
3963
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
972 |
end; |
6090d2a2472e
New Weapon: Resurrector (TODO: ammo icon + sprites)
Tobias Neumann <mail@tobias-neumann.eu>
parents:
3957
diff
changeset
|
973 |
|
1433 | 974 |
{procedure AmmoFlameWork(Ammo: PGear); |
79 | 975 |
var t: PGear; |
976 |
begin |
|
977 |
t:= GearsList; |
|
978 |
while t <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
979 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
980 |
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
|
981 |
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
|
982 |
begin |
2017 | 983 |
ApplyDamage(t, 5); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
984 |
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
|
985 |
t^.dY:= - _0_25; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
986 |
t^.Active:= true; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
987 |
DeleteCI(t); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
988 |
FollowGear:= t |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
989 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
990 |
t:= t^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
991 |
end; |
1433 | 992 |
end;} |
79 | 993 |
|
16 | 994 |
|
995 |
function CountGears(Kind: TGearType): Longword; |
|
996 |
var t: PGear; |
|
2695 | 997 |
count: Longword = 0; |
16 | 998 |
begin |
2695 | 999 |
|
16 | 1000 |
t:= GearsList; |
1001 |
while t <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1002 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1003 |
if t^.Kind = Kind then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1004 |
inc(count); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1005 |
t:= t^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1006 |
end; |
2695 | 1007 |
CountGears:= count; |
16 | 1008 |
end; |
1009 |
||
7337
c224cd2d32f3
Allow script to set number of ammo in a crate. untested.
nemo
parents:
7335
diff
changeset
|
1010 |
function SpawnCustomCrateAt(x, y: LongInt; crate: TCrateType; content, cnt: Longword): PGear; |
3730 | 1011 |
begin |
3734 | 1012 |
FollowGear := AddGear(x, y, gtCase, 0, _0, _0, 0); |
1013 |
cCaseFactor := 0; |
|
1014 |
||
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1015 |
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
|
1016 |
content := ord(High(TAmmoType)); |
3734 | 1017 |
|
7337
c224cd2d32f3
Allow script to set number of ammo in a crate. untested.
nemo
parents:
7335
diff
changeset
|
1018 |
FollowGear^.Power:= cnt; |
c224cd2d32f3
Allow script to set number of ammo in a crate. untested.
nemo
parents:
7335
diff
changeset
|
1019 |
|
3734 | 1020 |
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
|
1021 |
HealthCrate: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1022 |
begin |
3734 | 1023 |
FollowGear^.Pos := posCaseHealth; |
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
|
1024 |
FollowGear^.Health := content; |
3734 | 1025 |
AddCaption(GetEventString(eidNewHealthPack), cWhiteColor, capgrpAmmoInfo); |
1026 |
end; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1027 |
AmmoCrate: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1028 |
begin |
3734 | 1029 |
FollowGear^.Pos := posCaseAmmo; |
4240
4e81670e52aa
er. and cast to TAmmoType, which burp's routine still requires :)
nemo
parents:
4239
diff
changeset
|
1030 |
FollowGear^.AmmoType := TAmmoType(content); |
3734 | 1031 |
AddCaption(GetEventString(eidNewAmmoPack), cWhiteColor, capgrpAmmoInfo); |
1032 |
end; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1033 |
UtilityCrate: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1034 |
begin |
3734 | 1035 |
FollowGear^.Pos := posCaseUtility; |
4240
4e81670e52aa
er. and cast to TAmmoType, which burp's routine still requires :)
nemo
parents:
4239
diff
changeset
|
1036 |
FollowGear^.AmmoType := TAmmoType(content); |
3734 | 1037 |
AddCaption(GetEventString(eidNewUtilityPack), cWhiteColor, capgrpAmmoInfo); |
1038 |
end; |
|
1039 |
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
|
1040 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1041 |
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
|
1042 |
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
|
1043 |
|
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
|
1044 |
SpawnCustomCrateAt := FollowGear; |
3730 | 1045 |
end; |
1046 |
||
5343 | 1047 |
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
|
1048 |
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
|
1049 |
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
|
1050 |
cCaseFactor := 0; |
5343 | 1051 |
FollowGear^.Pos := posCaseDummy; |
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
|
1052 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1053 |
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
|
1054 |
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
|
1055 |
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
|
1056 |
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
|
1057 |
|
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
|
1058 |
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
|
1059 |
HealthCrate: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1060 |
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
|
1061 |
FollowGear^.Pos := FollowGear^.Pos + posCaseHealth; |
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
|
1062 |
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
|
1063 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1064 |
AmmoCrate: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1065 |
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
|
1066 |
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
|
1067 |
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
|
1068 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1069 |
UtilityCrate: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1070 |
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
|
1071 |
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
|
1072 |
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
|
1073 |
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
|
1074 |
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
|
1075 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1076 |
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
|
1077 |
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
|
1078 |
|
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
|
1079 |
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
|
1080 |
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
|
1081 |
|
6515
74a04089bb56
Suggestion of sheepluva's - disable timebox in crates after SD, and set to disabled in Ammo. Also disable switch hedgehog for teams of 1 hedgehog in size, and try and correct what appears to be a bug in reserved hats.
nemo
parents:
6472
diff
changeset
|
1082 |
function GetAmmo(Hedgehog: PHedgehog): TAmmoType; |
5584
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1083 |
var t, aTot: LongInt; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1084 |
i: TAmmoType; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1085 |
begin |
6992 | 1086 |
Hedgehog:= Hedgehog; // avoid hint |
5584
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1087 |
|
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1088 |
aTot:= 0; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1089 |
for i:= Low(TAmmoType) to High(TAmmoType) do |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1090 |
if (Ammoz[i].Ammo.Propz and ammoprop_Utility) = 0 then |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1091 |
inc(aTot, Ammoz[i].Probability); |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1092 |
|
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1093 |
t:= aTot; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1094 |
i:= Low(TAmmoType); |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1095 |
if (t > 0) then |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1096 |
begin |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1097 |
t:= GetRandom(t); |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1098 |
while t >= 0 do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1099 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1100 |
inc(i); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1101 |
if (Ammoz[i].Ammo.Propz and ammoprop_Utility) = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1102 |
dec(t, Ammoz[i].Probability) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1103 |
end |
5584
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1104 |
end; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1105 |
GetAmmo:= i |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1106 |
end; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1107 |
|
6515
74a04089bb56
Suggestion of sheepluva's - disable timebox in crates after SD, and set to disabled in Ammo. Also disable switch hedgehog for teams of 1 hedgehog in size, and try and correct what appears to be a bug in reserved hats.
nemo
parents:
6472
diff
changeset
|
1108 |
function GetUtility(Hedgehog: PHedgehog): TAmmoType; |
5584
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1109 |
var t, uTot: LongInt; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1110 |
i: TAmmoType; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1111 |
begin |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1112 |
|
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1113 |
uTot:= 0; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1114 |
for i:= Low(TAmmoType) to High(TAmmoType) do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1115 |
if ((Ammoz[i].Ammo.Propz and ammoprop_Utility) <> 0) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1116 |
and ((Hedgehog^.Team^.HedgehogsNumber > 1) or (Ammoz[i].Ammo.AmmoType <> amSwitch)) then |
5584
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1117 |
inc(uTot, Ammoz[i].Probability); |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1118 |
|
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1119 |
t:= uTot; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1120 |
i:= Low(TAmmoType); |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1121 |
if (t > 0) then |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1122 |
begin |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1123 |
t:= GetRandom(t); |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1124 |
while t >= 0 do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1125 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1126 |
inc(i); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1127 |
if ((Ammoz[i].Ammo.Propz and ammoprop_Utility) <> 0) and ((Hedgehog^.Team^.HedgehogsNumber > 1) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1128 |
or (Ammoz[i].Ammo.AmmoType <> amSwitch)) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1129 |
dec(t, Ammoz[i].Probability) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1130 |
end |
5584
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1131 |
end; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1132 |
GetUtility:= i |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1133 |
end; |
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1134 |
|
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1135 |
|
e0b9722bd653
Make it a lot harder to cheat with typical random crates. This also means that crates will vary even if map has the same seed (hog positions of course will be unchanged).
nemo
parents:
5564
diff
changeset
|
1136 |
|
15 | 1137 |
procedure SpawnBoxOfSmth; |
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1138 |
var t, aTot, uTot, a, h: LongInt; |
394
4c017ae1226a
- Implement hack to let ammo stores work without needed assistance of frontend
unc0rr
parents:
393
diff
changeset
|
1139 |
i: TAmmoType; |
15 | 1140 |
begin |
2762
2fbc8d35eb52
Mode to place hogs at start of game. Will probably need a bit more testing.
nemo
parents:
2760
diff
changeset
|
1141 |
if (PlacingHogs) or |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1142 |
(cCaseFactor = 0) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1143 |
or (CountGears(gtCase) >= 5) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1144 |
or (GetRandom(cCaseFactor) <> 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6543
diff
changeset
|
1145 |
exit; |
1295 | 1146 |
|
1948 | 1147 |
FollowGear:= nil; |
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1148 |
aTot:= 0; |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1149 |
uTot:= 0; |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1150 |
for i:= Low(TAmmoType) to High(TAmmoType) do |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1151 |
if (Ammoz[i].Ammo.Propz and ammoprop_Utility) = 0 then |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1152 |
inc(aTot, Ammoz[i].Probability) |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1153 |
else |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1154 |
inc(uTot, Ammoz[i].Probability); |
1966 | 1155 |
|
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1156 |
t:=0; |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1157 |
a:=aTot; |
3268 | 1158 |
h:= 1; |
4143
eb7981f34800
Remove the last vestiges of the shoppa hack by adding 2 spinners for percentage health and amount of health in crate, also update translations and increase SD spinner (some users have requested it)
henek
parents:
4120
diff
changeset
|
1159 |
|
3268 | 1160 |
if (aTot+uTot) <> 0 then |
4143
eb7981f34800
Remove the last vestiges of the shoppa hack by adding 2 spinners for percentage health and amount of health in crate, also update translations and increase SD spinner (some users have requested it)
henek
parents:
4120
diff
changeset
|
1161 |
if ((GameFlags and gfInvulnerable) = 0) then |
3268 | 1162 |
begin |
4143
eb7981f34800
Remove the last vestiges of the shoppa hack by adding 2 spinners for percentage health and amount of health in crate, also update translations and increase SD spinner (some users have requested it)
henek
parents:
4120
diff
changeset
|
1163 |
h:= cHealthCaseProb * 100; |
3268 | 1164 |
t:= GetRandom(10000); |
4143
eb7981f34800
Remove the last vestiges of the shoppa hack by adding 2 spinners for percentage health and amount of health in crate, also update translations and increase SD spinner (some users have requested it)
henek
parents:
4120
diff
changeset
|
1165 |
a:= (10000-h)*aTot div (aTot+uTot) |
3268 | 1166 |
end |
3697 | 1167 |
else |
3268 | 1168 |
begin |
1169 |
t:= GetRandom(aTot+uTot); |
|
1170 |
h:= 0 |
|
1171 |
end; |
|
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1172 |
|
3697 | 1173 |
|
3261
fa7086253e83
Rebalance Default to take into account reweighting of crates, remove redundant check
nemo
parents:
3259
diff
changeset
|
1174 |
if t<h then |
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1175 |
begin |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1176 |
FollowGear:= AddGear(0, 0, gtCase, 0, _0, _0, 0); |
4143
eb7981f34800
Remove the last vestiges of the shoppa hack by adding 2 spinners for percentage health and amount of health in crate, also update translations and increase SD spinner (some users have requested it)
henek
parents:
4120
diff
changeset
|
1177 |
FollowGear^.Health:= cHealthCaseAmount; |
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1178 |
FollowGear^.Pos:= posCaseHealth; |
3331 | 1179 |
AddCaption(GetEventString(eidNewHealthPack), cWhiteColor, capgrpAmmoInfo); |
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1180 |
end |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1181 |
else if (t<a+h) then |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1182 |
begin |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1183 |
t:= aTot; |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1184 |
if (t > 0) then |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1185 |
begin |
1865
ebc6dfca60d4
- nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1863
diff
changeset
|
1186 |
FollowGear:= AddGear(0, 0, gtCase, 0, _0, _0, 0); |
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1187 |
t:= GetRandom(t); |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1188 |
i:= Low(TAmmoType); |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1189 |
FollowGear^.Pos:= posCaseAmmo; |
4238
6f1631765ebd
Fix a long-standing bug with ammo due to gstMoving being set on gears generically, causing an incorrect ammo type to be set. This caused crashes and incorrect ammo types.
nemo
parents:
4225
diff
changeset
|
1190 |
FollowGear^.AmmoType:= i; |
3331 | 1191 |
AddCaption(GetEventString(eidNewAmmoPack), cWhiteColor, capgrpAmmoInfo); |
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1192 |
end |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1193 |
end |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1194 |
else |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1195 |
begin |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1196 |
t:= uTot; |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1197 |
if (t > 0) then |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1198 |
begin |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1199 |
FollowGear:= AddGear(0, 0, gtCase, 0, _0, _0, 0); |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1200 |
t:= GetRandom(t); |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1201 |
i:= Low(TAmmoType); |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1202 |
FollowGear^.Pos:= posCaseUtility; |
4238
6f1631765ebd
Fix a long-standing bug with ammo due to gstMoving being set on gears generically, causing an incorrect ammo type to be set. This caused crashes and incorrect ammo types.
nemo
parents:
4225
diff
changeset
|
1203 |
FollowGear^.AmmoType:= i; |
3331 | 1204 |
AddCaption(GetEventString(eidNewUtilityPack), cWhiteColor, capgrpAmmoInfo); |
3259
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1205 |
end |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1206 |
end; |
a29ccf4aed82
This attempts to distribute crates based on their probabilities, while preserving 35% for health crates since that has no probability GUI yet
nemo
parents:
3255
diff
changeset
|
1207 |
|
1865
ebc6dfca60d4
- nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1863
diff
changeset
|
1208 |
// handles case of no ammo or utility crates - considered also placing booleans in uAmmos and altering probabilities |
ebc6dfca60d4
- nemo's patch: some animations, zero probability for infinite weapons
unc0rr
parents:
1863
diff
changeset
|
1209 |
if (FollowGear <> nil) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1210 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1211 |
FindPlace(FollowGear, true, 0, LAND_WIDTH); |
2376 | 1212 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1213 |
if (FollowGear <> nil) then |
5638
e35ba2a400d8
Try to avoid overlapping voices for major statements (not things like byebye or oof)
nemo
parents:
5622
diff
changeset
|
1214 |
AddVoice(sndReinforce, CurrentTeam^.voicepack) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1215 |
end |
70 | 1216 |
end; |
1217 |
||
2726 | 1218 |
|
2790 | 1219 |
function GearByUID(uid : Longword) : PGear; |
1220 |
var gear: PGear; |
|
1221 |
begin |
|
1222 |
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
|
1223 |
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
|
1224 |
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
|
1225 |
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
|
1226 |
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
|
1227 |
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
|
1228 |
end; |
2790 | 1229 |
gear:= GearsList; |
1230 |
while gear <> nil do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1231 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1232 |
if gear^.uid = uid then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1233 |
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
|
1234 |
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
|
1235 |
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
|
1236 |
exit |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1237 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1238 |
gear:= gear^.NextGear |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1239 |
end |
2790 | 1240 |
end; |
1241 |
||
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
|
1242 |
|
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
|
1243 |
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
|
1244 |
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
|
1245 |
s:= s; // avoid compiler hint |
7805 | 1246 |
if not isExternalSource then |
7068 | 1247 |
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
|
1248 |
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
|
1249 |
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
|
1250 |
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
|
1251 |
|
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
|
1252 |
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
|
1253 |
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
|
1254 |
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
|
1255 |
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
|
1256 |
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
|
1257 |
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
|
1258 |
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
|
1259 |
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
|
1260 |
i:= 0; |
4469 | 1261 |
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
|
1262 |
x:= byte(s[1]); // speech type |
4469 | 1263 |
if x < 4 then |
1264 |
begin |
|
1265 |
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
|
1266 |
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
|
1267 |
h:= byte(s[3]) // target hog |
4469 | 1268 |
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
|
1269 |
// 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
|
1270 |
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
|
1271 |
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
|
1272 |
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
|
1273 |
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
|
1274 |
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
|
1275 |
text:= copy(s, 3, Length(s) - 1) |
4468 | 1276 |
else text:= copy(s, 2, Length(s) - 1); |
1277 |
||
4470
d2b8d2fc51a9
disable say, just don't do anything. trying to avoid spew on spectator join
nemo
parents:
4469
diff
changeset
|
1278 |
(* |
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
|
1279 |
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
|
1280 |
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
|
1281 |
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
|
1282 |
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
|
1283 |
end; |
4470
d2b8d2fc51a9
disable say, just don't do anything. trying to avoid spew on spectator join
nemo
parents:
4469
diff
changeset
|
1284 |
*) |
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
|
1285 |
|
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
|
1286 |
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
|
1287 |
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
|
1288 |
// 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
|
1289 |
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
|
1290 |
hh:= CurrentHedgehog |
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
|
1291 |
else |
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
|
1292 |
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
|
1293 |
// 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
|
1294 |
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
|
1295 |
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
|
1296 |
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
|
1297 |
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
|
1298 |
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
|
1299 |
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
|
1300 |
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
|
1301 |
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
|
1302 |
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
|
1303 |
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
|
1304 |
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
|
1305 |
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
|
1306 |
end; |
4784 | 1307 |
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
|
1308 |
begin |
4784 | 1309 |
Gear:= AddVisualGear(0, 0, vgtSpeechBubble); |
1310 |
if Gear <> nil then |
|
1311 |
begin |
|
1312 |
Gear^.Hedgehog:= hh; |
|
1313 |
Gear^.Text:= text; |
|
1314 |
Gear^.FrameTicks:= x |
|
1315 |
end |
|
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4396
diff
changeset
|
1316 |
end |
4706 | 1317 |
//else ParseCommand('say ' + text, 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
|
1318 |
end |
4470
d2b8d2fc51a9
disable say, just don't do anything. trying to avoid spew on spectator join
nemo
parents:
4469
diff
changeset
|
1319 |
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
|
1320 |
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
|
1321 |
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
|
1322 |
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
|
1323 |
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
|
1324 |
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
|
1325 |
|
3038 | 1326 |
procedure initModule; |
6543 | 1327 |
const handlers: array[TGearType] of TGearStepProcedure = ( |
6890 | 1328 |
@doStepFlame, |
1329 |
@doStepHedgehog, |
|
1330 |
@doStepMine, |
|
1331 |
@doStepCase, |
|
1332 |
@doStepCase, |
|
6543 | 1333 |
@doStepBomb, |
1334 |
@doStepShell, |
|
1335 |
@doStepGrave, |
|
1336 |
@doStepBee, |
|
1337 |
@doStepShotgunShot, |
|
1338 |
@doStepPickHammer, |
|
1339 |
@doStepRope, |
|
1340 |
@doStepDEagleShot, |
|
1341 |
@doStepDynamite, |
|
1342 |
@doStepBomb, |
|
1343 |
@doStepCluster, |
|
1344 |
@doStepShover, |
|
1345 |
@doStepFirePunch, |
|
1346 |
@doStepActionTimer, |
|
1347 |
@doStepActionTimer, |
|
1348 |
@doStepParachute, |
|
1349 |
@doStepAirAttack, |
|
1350 |
@doStepAirBomb, |
|
1351 |
@doStepBlowTorch, |
|
1352 |
@doStepGirder, |
|
1353 |
@doStepTeleport, |
|
1354 |
@doStepSwitcher, |
|
1355 |
@doStepTarget, |
|
1356 |
@doStepMortar, |
|
1357 |
@doStepWhip, |
|
1358 |
@doStepKamikaze, |
|
1359 |
@doStepCake, |
|
1360 |
@doStepSeduction, |
|
1361 |
@doStepBomb, |
|
1362 |
@doStepCluster, |
|
1363 |
@doStepBomb, |
|
1364 |
@doStepWaterUp, |
|
1365 |
@doStepDrill, |
|
1366 |
@doStepBallgun, |
|
1367 |
@doStepBomb, |
|
1368 |
@doStepRCPlane, |
|
1369 |
@doStepSniperRifleShot, |
|
1370 |
@doStepJetpack, |
|
1371 |
@doStepMolotov, |
|
1372 |
@doStepBirdy, |
|
1373 |
@doStepEggWork, |
|
1374 |
@doStepPortalShot, |
|
1375 |
@doStepPiano, |
|
1376 |
@doStepBomb, |
|
1377 |
@doStepSineGunShot, |
|
1378 |
@doStepFlamethrower, |
|
1379 |
@doStepSMine, |
|
1380 |
@doStepPoisonCloud, |
|
1381 |
@doStepHammer, |
|
1382 |
@doStepHammerHit, |
|
1383 |
@doStepResurrector, |
|
1384 |
@doStepNapalmBomb, |
|
1385 |
@doStepSnowball, |
|
1386 |
@doStepSnowflake, |
|
8161 | 1387 |
//@doStepStructure, |
6543 | 1388 |
@doStepLandGun, |
7007 | 1389 |
@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
|
1390 |
@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
|
1391 |
@doStepAddAmmo, |
7730
2013733f9ca9
A bit more on the knife. Also add missing files to CMakeLists
nemo
parents:
7721
diff
changeset
|
1392 |
@doStepGenericFaller, |
2013733f9ca9
A bit more on the knife. Also add missing files to CMakeLists
nemo
parents:
7721
diff
changeset
|
1393 |
@doStepKnife); |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
1394 |
begin |
6543 | 1395 |
doStepHandlers:= handlers; |
1396 |
||
6898 | 1397 |
RegisterVariable('skip', @chSkip, false); |
1398 |
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
|
1399 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1400 |
CurAmmoGear:= nil; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1401 |
GearsList:= nil; |
7395 | 1402 |
curHandledGear:= nil; |
1403 |
||
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1404 |
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
|
1405 |
SuddenDeath:= false; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1406 |
SuddenDeathDmg:= false; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1407 |
SpeechType:= 1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1408 |
skipFlag:= false; |
3697 | 1409 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1410 |
AllInactive:= false; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2947
diff
changeset
|
1411 |
PrvInactive:= false; |
6982 | 1412 |
|
1413 |
//typed const |
|
1414 |
delay:= 0; |
|
1415 |
delay2:= 0; |
|
1416 |
step:= stDelay; |
|
1417 |
upd:= 0; |
|
7021
0c75512a8920
adjust the scope of a few uSound variables and functions
koda
parents:
7010
diff
changeset
|
1418 |
|
0c75512a8920
adjust the scope of a few uSound variables and functions
koda
parents:
7010
diff
changeset
|
1419 |
//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
|
1420 |
NewTurnTick:= $FFFFFFFF; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
1421 |
end; |
4 | 1422 |
|
3038 | 1423 |
procedure freeModule; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
1424 |
begin |
3615 | 1425 |
FreeGearsList(); |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
1426 |
end; |
4 | 1427 |
|
2451
5affd0840927
New data files from Tiy, add gtFlame to avoidance list
nemo
parents:
2428
diff
changeset
|
1428 |
end. |