author | Wuzzy <Wuzzy2@mail.ru> |
Thu, 15 Mar 2018 21:15:16 +0100 | |
changeset 13226 | 02bf6902eeb0 |
parent 13156 | deab88f1f6f7 |
child 13240 | 9f5023a5f9e1 |
permissions | -rw-r--r-- |
802
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
11046 | 3 |
* Copyright (c) 2004-2015 Andrey Korotaev <unC0Rr@gmail.com> |
802
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
4 |
* |
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
5 |
* This program is free software; you can redistribute it and/or modify |
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
6 |
* it under the terms of the GNU General Public License as published by |
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
7 |
* the Free Software Foundation; version 2 of the License |
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
8 |
* |
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
9 |
* This program is distributed in the hope that it will be useful, |
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
10 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
11 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
12 |
* GNU General Public License for more details. |
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
13 |
* |
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
14 |
* You should have received a copy of the GNU General Public License |
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
15 |
* along with this program; if not, write to the Free Software |
10108
c68cf030eded
update FSF address. note: two sdl include files (by Sam Lantinga) still have the old FSF address in their copyright - but I ain't gonna touch their copyright headers
sheepluva
parents:
10015
diff
changeset
|
16 |
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
802
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
17 |
*) |
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
18 |
|
2599 | 19 |
{$INCLUDE "options.inc"} |
2587
0dfa56a8513c
fix a segfault in the iphone simulator by moving options.inc at the beginning of the file
koda
parents:
2428
diff
changeset
|
20 |
|
802
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
21 |
unit uVisualGears; |
5121
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5065
diff
changeset
|
22 |
(* |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5065
diff
changeset
|
23 |
* This unit defines the behavior and the appearance of visual gears. |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5065
diff
changeset
|
24 |
* |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5065
diff
changeset
|
25 |
* Visual gears are "things"/"objects" in the game that do not need to be |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5065
diff
changeset
|
26 |
* perfectly synchronized over all clients since their effect is only |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5065
diff
changeset
|
27 |
* of visual nature. |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5065
diff
changeset
|
28 |
* |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5065
diff
changeset
|
29 |
* E.g.: background flakes, visual effects: explosion, smoke trails, etc. |
2d34ec60992c
added some comments in order to confuse the GSoC students as much as possible ;D
sheepluva
parents:
5065
diff
changeset
|
30 |
*) |
802
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
31 |
interface |
9285 | 32 |
uses uConsts, GLunit, uTypes; |
802
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
33 |
|
3038 | 34 |
procedure initModule; |
35 |
procedure freeModule; |
|
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2715
diff
changeset
|
36 |
|
802
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
37 |
procedure ProcessVisualGears(Steps: Longword); |
1045 | 38 |
procedure DrawVisualGears(Layer: LongWord); |
6986
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6982
diff
changeset
|
39 |
|
803 | 40 |
procedure AddClouds; |
4806
48c1a395f0a7
added flake configuration also in sudden death and SDClouds for underwater
Henek
parents:
4792
diff
changeset
|
41 |
procedure AddFlakes; |
6986
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6982
diff
changeset
|
42 |
procedure AddDamageTag(X, Y, Damage, Color: LongWord); |
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6982
diff
changeset
|
43 |
|
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6982
diff
changeset
|
44 |
procedure ChangeToSDClouds; |
4806
48c1a395f0a7
added flake configuration also in sudden death and SDClouds for underwater
Henek
parents:
4792
diff
changeset
|
45 |
procedure ChangeToSDFlakes; |
6986
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6982
diff
changeset
|
46 |
|
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6982
diff
changeset
|
47 |
procedure KickFlakes(Radius, X, Y: LongInt); |
802
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
48 |
|
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
49 |
implementation |
10302
ea0b0e2efd95
huh? me? nono, don't mind me. I'm just here to clean up.
sheepluva
parents:
10301
diff
changeset
|
50 |
uses uVariables, uRender, Math, uRenderUtils, uUtils |
9285 | 51 |
, uVisualGearsList; |
3440
dee31c5149e0
* gtHealthTag, gtSmokeTrace, gtEvilTrace, gtExplosion and gtBigExplosion are visual gears now (vgt*)
sheepluva
parents:
3420
diff
changeset
|
52 |
|
1505 | 53 |
procedure AddDamageTag(X, Y, Damage, Color: LongWord); |
10121 | 54 |
var Gear: PVisualGear; |
1505 | 55 |
begin |
56 |
if cAltDamage then |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2941
diff
changeset
|
57 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2941
diff
changeset
|
58 |
Gear:= AddVisualGear(X, Y, vgtSmallDamageTag); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2941
diff
changeset
|
59 |
if Gear <> nil then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2941
diff
changeset
|
60 |
with Gear^ do |
10121 | 61 |
Tex:= RenderStringTex(ansistring(inttostr(Damage)), Color, fntSmall); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2941
diff
changeset
|
62 |
end |
1505 | 63 |
end; |
64 |
||
65 |
||
803 | 66 |
// ================================================================== |
2042
905c554d62e6
Move Speech to visual gears. This checkin CRASHES on deletion of visual gear outside the doStep
nemo
parents:
2014
diff
changeset
|
67 |
|
802
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
68 |
procedure ProcessVisualGears(Steps: Longword); |
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
69 |
var Gear, t: PVisualGear; |
6179
b529f88d37d0
Bit of an experiment with giving flakes a bit more depth. Might need to be theme flagged, or theme flakes reworked on some themes. Looks neat in stereo. Also finally use an array for the layers
nemo
parents:
6117
diff
changeset
|
70 |
i: LongWord; |
802
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
71 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
72 |
if Steps = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
73 |
exit; |
803 | 74 |
|
6302
db8bdbb34e03
Spread flakes out over 5 layers now (far back, mid distance, just behind land, just in front of lands and hog, near distance). Spread clouds out over 3 layers (far back, mid distance, just behind land). Add a flatten clouds option, use
nemo
parents:
6291
diff
changeset
|
75 |
for i:= 0 to 6 do |
6179
b529f88d37d0
Bit of an experiment with giving flakes a bit more depth. Might need to be theme flagged, or theme flakes reworked on some themes. Looks neat in stereo. Also finally use an array for the layers
nemo
parents:
6117
diff
changeset
|
76 |
begin |
b529f88d37d0
Bit of an experiment with giving flakes a bit more depth. Might need to be theme flagged, or theme flakes reworked on some themes. Looks neat in stereo. Also finally use an array for the layers
nemo
parents:
6117
diff
changeset
|
77 |
t:= VisualGearLayers[i]; |
b529f88d37d0
Bit of an experiment with giving flakes a bit more depth. Might need to be theme flagged, or theme flakes reworked on some themes. Looks neat in stereo. Also finally use an array for the layers
nemo
parents:
6117
diff
changeset
|
78 |
while t <> nil do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
79 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
80 |
Gear:= t; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
81 |
t:= Gear^.NextGear; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
82 |
Gear^.doStep(Gear, Steps) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
83 |
end; |
6179
b529f88d37d0
Bit of an experiment with giving flakes a bit more depth. Might need to be theme flagged, or theme flakes reworked on some themes. Looks neat in stereo. Also finally use an array for the layers
nemo
parents:
6117
diff
changeset
|
84 |
end |
802
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
85 |
end; |
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
86 |
|
3083
8da8f2515221
Eliminate flake kick on themes with no flakes, more than 200 flakes (city) or explosions of 25 or smaller
nemo
parents:
3080
diff
changeset
|
87 |
procedure KickFlakes(Radius, X, Y: LongInt); |
2985
d268a7fbb868
Kick flakes a bit when an explosion is nearby. Needs testing / review by those more artistically inclined
nemo
parents:
2982
diff
changeset
|
88 |
var Gear, t: PVisualGear; |
6302
db8bdbb34e03
Spread flakes out over 5 layers now (far back, mid distance, just behind land, just in front of lands and hog, near distance). Spread clouds out over 3 layers (far back, mid distance, just behind land). Add a flatten clouds option, use
nemo
parents:
6291
diff
changeset
|
89 |
dmg, i: LongInt; |
2985
d268a7fbb868
Kick flakes a bit when an explosion is nearby. Needs testing / review by those more artistically inclined
nemo
parents:
2982
diff
changeset
|
90 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
91 |
if (vobCount = 0) or (vobCount > 200) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
92 |
exit; |
6306 | 93 |
for i:= 2 to 6 do |
94 |
if i <> 3 then |
|
95 |
begin |
|
96 |
t:= VisualGearLayers[i]; |
|
97 |
while t <> nil do |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
98 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
99 |
Gear:= t; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
100 |
if Gear^.Kind = vgtFlake then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
101 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
102 |
// Damage calc from doMakeExplosion |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
103 |
dmg:= Min(101, Radius + cHHRadius div 2 - LongInt(abs(round(Gear^.X) - X) + abs(round(Gear^.Y) - Y)) div 5); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
104 |
if dmg > 1 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
105 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
106 |
Gear^.tdX:= 0.02 * dmg + 0.01; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
107 |
if Gear^.X - X < 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
108 |
Gear^.tdX := -Gear^.tdX; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
109 |
Gear^.tdY:= 0.02 * dmg + 0.01; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
110 |
if Gear^.Y - Y < 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
111 |
Gear^.tdY := -Gear^.tdY; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
112 |
Gear^.Timer:= 200 |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
113 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
114 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
115 |
t:= Gear^.NextGear |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
116 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
117 |
end |
2985
d268a7fbb868
Kick flakes a bit when an explosion is nearby. Needs testing / review by those more artistically inclined
nemo
parents:
2982
diff
changeset
|
118 |
end; |
d268a7fbb868
Kick flakes a bit when an explosion is nearby. Needs testing / review by those more artistically inclined
nemo
parents:
2982
diff
changeset
|
119 |
|
10361 | 120 |
function GetSprite(sprite, SDsprite: TSprite): TSprite; inline; |
121 |
begin |
|
122 |
if SuddenDeathDmg then |
|
123 |
exit(SDsprite) |
|
124 |
else |
|
125 |
exit(sprite); |
|
126 |
end; |
|
127 |
||
12163 | 128 |
function GetSpriteByWind(sprite, Lsprite: TSprite): TSprite; inline; |
129 |
begin |
|
130 |
if (SpritesData[Lsprite].Texture <> nil) and (cWindSpeedf<0) then |
|
131 |
exit(Lsprite) |
|
132 |
else |
|
133 |
exit(sprite); |
|
134 |
end; |
|
135 |
||
10361 | 136 |
function GetSpriteData(sprite, SDsprite: TSprite): PSpriteData; inline; |
137 |
begin |
|
138 |
exit(@SpritesData[GetSprite(sprite, SDsprite)]); |
|
139 |
end; |
|
140 |
||
1045 | 141 |
procedure DrawVisualGears(Layer: LongWord); |
802
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
142 |
var Gear: PVisualGear; |
10373 | 143 |
tinted, speedlessFlakes: boolean; |
4545 | 144 |
tmp: real; |
5748
70d7f8e40f53
Just for fun. Flowers! Also, use a less blatant image in ammo menu.
nemo
parents:
5690
diff
changeset
|
145 |
i: LongInt; |
10361 | 146 |
sprite: TSprite; |
147 |
spriteData: PSpriteData; |
|
802
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
148 |
begin |
10373 | 149 |
if SuddenDeathDmg then |
150 |
speedlessFlakes:= (vobSDVelocity = 0) |
|
151 |
else |
|
152 |
speedlessFlakes:= (vobVelocity = 0); |
|
153 |
||
1045 | 154 |
case Layer of |
5256
e3fada9358b0
fix water bubbles like sheepluva wanted (also code formatting)
koda
parents:
5179
diff
changeset
|
155 |
// this layer is very distant in the background when stereo |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
156 |
0: begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
157 |
Gear:= VisualGearLayers[0]; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
158 |
while Gear <> nil do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
159 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
160 |
if Gear^.Tint <> $FFFFFFFF then Tint(Gear^.Tint); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
161 |
case Gear^.Kind of |
10361 | 162 |
vgtCloud: begin |
12164 | 163 |
spriteData:= GetSpriteData(GetSpriteByWind(sprCloud, sprCloudL), GetSpriteByWind(sprSDCloud, sprSDCloudL)); |
10361 | 164 |
DrawTextureF(spriteData^.Texture, Gear^.Scale, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame, 1, spriteData^.Width, spriteData^.Height) |
165 |
end; |
|
166 |
vgtFlake: begin |
|
12163 | 167 |
sprite:= GetSpriteByWind(GetSprite(sprFlake, sprSDFlake), GetSprite(sprFlakeL, sprSDFlakeL)); |
10361 | 168 |
if cFlattenFlakes then |
6288
fcc50b96d20a
Flatten flakes for halloween theme, based on feedback from sheepluva
nemo
parents:
6184
diff
changeset
|
169 |
begin |
10373 | 170 |
if speedlessFlakes then |
10361 | 171 |
DrawSprite(sprite, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame) |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
172 |
else |
10361 | 173 |
DrawSpriteRotatedF(sprite, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame, 1, Gear^.Angle); |
6288
fcc50b96d20a
Flatten flakes for halloween theme, based on feedback from sheepluva
nemo
parents:
6184
diff
changeset
|
174 |
end |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
175 |
else |
6288
fcc50b96d20a
Flatten flakes for halloween theme, based on feedback from sheepluva
nemo
parents:
6184
diff
changeset
|
176 |
begin |
10373 | 177 |
if speedlessFlakes then |
10361 | 178 |
DrawTextureF(SpritesData[sprite].Texture, Gear^.Scale, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame, 1, SpritesData[sprFlake].Width, SpritesData[sprFlake].Height) |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
179 |
else |
10361 | 180 |
DrawTextureRotatedF(SpritesData[sprite].Texture, Gear^.Scale, 0, 0, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame, 1, SpritesData[sprFlake].Width, SpritesData[sprFlake].Height, Gear^.Angle); |
6288
fcc50b96d20a
Flatten flakes for halloween theme, based on feedback from sheepluva
nemo
parents:
6184
diff
changeset
|
181 |
end; |
10361 | 182 |
end; |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
183 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
184 |
if Gear^.Tint <> $FFFFFFFF then |
9666
8dcb25112d96
- Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9285
diff
changeset
|
185 |
untint; |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
186 |
Gear:= Gear^.NextGear |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
187 |
end |
5256
e3fada9358b0
fix water bubbles like sheepluva wanted (also code formatting)
koda
parents:
5179
diff
changeset
|
188 |
end; |
e3fada9358b0
fix water bubbles like sheepluva wanted (also code formatting)
koda
parents:
5179
diff
changeset
|
189 |
// this layer is on the land level (which is close but behind the screen plane) when stereo |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
190 |
1: begin |
6179
b529f88d37d0
Bit of an experiment with giving flakes a bit more depth. Might need to be theme flagged, or theme flakes reworked on some themes. Looks neat in stereo. Also finally use an array for the layers
nemo
parents:
6117
diff
changeset
|
191 |
Gear:= VisualGearLayers[1]; |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
192 |
while Gear <> nil do |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
193 |
begin |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
194 |
//tinted:= false; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
195 |
if Gear^.Tint <> $FFFFFFFF then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
196 |
Tint(Gear^.Tint); |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
197 |
case Gear^.Kind of |
10361 | 198 |
vgtFlake: begin |
12163 | 199 |
sprite:= GetSpriteByWind(GetSprite(sprFlake, sprSDFlake), GetSprite(sprFlakeL, sprSDFlakeL)); |
10373 | 200 |
if speedlessFlakes then |
10361 | 201 |
DrawSprite(sprite, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame) |
6179
b529f88d37d0
Bit of an experiment with giving flakes a bit more depth. Might need to be theme flagged, or theme flakes reworked on some themes. Looks neat in stereo. Also finally use an array for the layers
nemo
parents:
6117
diff
changeset
|
202 |
else |
10361 | 203 |
DrawSpriteRotatedF(sprite, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame, 1, Gear^.Angle); |
204 |
end; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
205 |
vgtSmokeTrace: if Gear^.State < 8 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
206 |
DrawSprite(sprSmokeTrace, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, Gear^.State); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
207 |
vgtEvilTrace: if Gear^.State < 8 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
208 |
DrawSprite(sprEvilTrace, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, Gear^.State); |
13156
deab88f1f6f7
Improve appearance of bullet trails, slight fade out at beginning
alfadur
parents:
13053
diff
changeset
|
209 |
vgtLineTrail: DrawLine(Gear^.X, Gear^.Y, Gear^.dX, Gear^.dY, 1.0, $FF, min(Gear^.Timer, $C0), min(Gear^.Timer, $80), min(Gear^.Timer, (Gear^.Tint and $FF))); |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
210 |
end; |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
211 |
if (cReducedQuality and rqAntiBoom) = 0 then |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
212 |
case Gear^.Kind of |
6323
c1aa6a3c84a7
Dir should not be 0, but set it to 1 if 0 in case I missed some other place this was done. Also correct cloud scaling.
nemo
parents:
6322
diff
changeset
|
213 |
vgtSmoke: DrawTextureF(SpritesData[sprSmoke].Texture, Gear^.scale, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, 7 - Gear^.Frame, 1, SpritesData[sprSmoke].Width, SpritesData[sprSmoke].Height); |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
214 |
vgtSmokeWhite: DrawSprite(sprSmokeWhite, round(Gear^.X) + WorldDx - 11, round(Gear^.Y) + WorldDy - 11, 7 - Gear^.Frame); |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
215 |
vgtDust: if Gear^.State = 1 then |
10675
cc3dea58794d
Issue 829: Drill rocket drilling dust is slightly misplaced
sheepluva
parents:
10658
diff
changeset
|
216 |
DrawSpriteRotatedF(sprSnowDust, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, 7 - Gear^.Frame, Gear^.Tag, Gear^.Angle) |
5256
e3fada9358b0
fix water bubbles like sheepluva wanted (also code formatting)
koda
parents:
5179
diff
changeset
|
217 |
else |
10675
cc3dea58794d
Issue 829: Drill rocket drilling dust is slightly misplaced
sheepluva
parents:
10658
diff
changeset
|
218 |
DrawSpriteRotatedF(sprDust, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, 7 - Gear^.Frame, Gear^.Tag, Gear^.Angle); |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
219 |
vgtFire: if (Gear^.State and gstTmpFlag) = 0 then |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
220 |
DrawSprite(sprFlame, round(Gear^.X) + WorldDx - 8, round(Gear^.Y) + WorldDy, (RealTicks shr 6 + Gear^.Frame) mod 8) |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
221 |
else |
6322
b310f0bc8dde
If I'm going to be arbitrary about it, might as well go for the more minimal arbitrariness
nemo
parents:
6318
diff
changeset
|
222 |
DrawTextureF(SpritesData[sprFlame].Texture, Gear^.FrameTicks / 900, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, (RealTicks shr 7 + Gear^.Frame) mod 8, 1, 16, 16); |
10361 | 223 |
vgtSplash: begin |
10584
f44ec13e3082
fix copypasta-fail that would cause splashes to use invalid sprite data pointer. should fix issue 838
sheepluva
parents:
10373
diff
changeset
|
224 |
spriteData:= GetSpriteData(sprSplash, sprSDSplash); |
10361 | 225 |
if Gear^.Angle <> 0 then |
226 |
DrawTextureRotatedF(spriteData^.Texture, Gear^.scale, 0, 0, round(Gear^.X + WorldDx + (((spriteData^.Height+8)*Gear^.Scale)/2) * (Gear^.Angle / abs(Gear^.Angle))), round(Gear^.Y + WorldDy), 19 - (Gear^.FrameTicks div Gear^.Timer div 37), 1, spriteData^.Width, spriteData^.Height, Gear^.Angle) |
|
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
227 |
else |
10361 | 228 |
//DrawSprite(sprite, round(Gear^.X) + WorldDx - 40, round(Gear^.Y) + WorldDy - 58, 19 - (Gear^.FrameTicks div 37)) |
229 |
DrawTextureF(spriteData^.Texture, Gear^.scale, round(Gear^.X + WorldDx), round(Gear^.Y + WorldDy - ((spriteData^.Height+8)*Gear^.Scale)/2), 19 - (Gear^.FrameTicks div Gear^.Timer div 37), 1, spriteData^.Width, spriteData^.Height); |
|
230 |
end; |
|
231 |
vgtDroplet: begin |
|
232 |
sprite:= GetSprite(sprDroplet, sprSDDroplet); |
|
233 |
DrawSprite(sprite, round(Gear^.X) + WorldDx - 8, round(Gear^.Y) + WorldDy - 8, Gear^.Frame); |
|
234 |
end; |
|
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
235 |
vgtBubble: DrawSprite(sprBubbles, round(Gear^.X) + WorldDx - 8, round(Gear^.Y) + WorldDy - 8, Gear^.Frame);//(RealTicks div 64 + Gear^.Frame) mod 8); |
10015 | 236 |
vgtStraightShot: begin |
9769
5814e0c47c99
Experiment in adding a "boing" graphic for bouncing. It has no text right now (was thinking l10n) and colour is fixed.
nemo
parents:
9768
diff
changeset
|
237 |
if Gear^.dX < 0 then |
5814e0c47c99
Experiment in adding a "boing" graphic for bouncing. It has no text right now (was thinking l10n) and colour is fixed.
nemo
parents:
9768
diff
changeset
|
238 |
i:= -1 |
5814e0c47c99
Experiment in adding a "boing" graphic for bouncing. It has no text right now (was thinking l10n) and colour is fixed.
nemo
parents:
9768
diff
changeset
|
239 |
else |
5814e0c47c99
Experiment in adding a "boing" graphic for bouncing. It has no text right now (was thinking l10n) and colour is fixed.
nemo
parents:
9768
diff
changeset
|
240 |
i:= 1; |
5814e0c47c99
Experiment in adding a "boing" graphic for bouncing. It has no text right now (was thinking l10n) and colour is fixed.
nemo
parents:
9768
diff
changeset
|
241 |
DrawTextureRotatedF(SpritesData[TSprite(Gear^.State)].Texture, Gear^.Scale, 0, 0, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, Gear^.Frame, i, SpritesData[TSprite(Gear^.State)].Width, SpritesData[TSprite(Gear^.State)].Height, Gear^.Angle); |
5814e0c47c99
Experiment in adding a "boing" graphic for bouncing. It has no text right now (was thinking l10n) and colour is fixed.
nemo
parents:
9768
diff
changeset
|
242 |
end; |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
243 |
end; |
9666
8dcb25112d96
- Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9285
diff
changeset
|
244 |
//if (Gear^.Tint <> $FFFFFFFF) or tinted then untint; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
245 |
if (Gear^.Tint <> $FFFFFFFF) then |
9666
8dcb25112d96
- Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9285
diff
changeset
|
246 |
untint; |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
247 |
Gear:= Gear^.NextGear |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
248 |
end |
5256
e3fada9358b0
fix water bubbles like sheepluva wanted (also code formatting)
koda
parents:
5179
diff
changeset
|
249 |
end; |
e3fada9358b0
fix water bubbles like sheepluva wanted (also code formatting)
koda
parents:
5179
diff
changeset
|
250 |
// this layer is on the screen plane (depth = 0) when stereo |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
251 |
3: begin |
6179
b529f88d37d0
Bit of an experiment with giving flakes a bit more depth. Might need to be theme flagged, or theme flakes reworked on some themes. Looks neat in stereo. Also finally use an array for the layers
nemo
parents:
6117
diff
changeset
|
252 |
Gear:= VisualGearLayers[3]; |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
253 |
while Gear <> nil do |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
254 |
begin |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
255 |
tinted:= false; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
256 |
if Gear^.Tint <> $FFFFFFFF then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
257 |
Tint(Gear^.Tint); |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
258 |
case Gear^.Kind of |
6302
db8bdbb34e03
Spread flakes out over 5 layers now (far back, mid distance, just behind land, just in front of lands and hog, near distance). Spread clouds out over 3 layers (far back, mid distance, just behind land). Add a flatten clouds option, use
nemo
parents:
6291
diff
changeset
|
259 |
(* |
10361 | 260 |
vgtFlake: begin |
261 |
sprite:= GetSprite(sprFlake, sprSDFlake); |
|
10373 | 262 |
if speedlessFlakes then |
10361 | 263 |
DrawSprite(sprite, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame) |
264 |
else |
|
265 |
DrawSpriteRotatedF(sprite, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame, 1, Gear^.Angle) |
|
266 |
end;*) |
|
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
267 |
vgtSpeechBubble: begin |
10193
d7cd5b43588f
By request. Allow lua to make random things "talk". I'm not sure if this is a good idea, buuuut.
nemo
parents:
10121
diff
changeset
|
268 |
if (Gear^.Tex <> nil) and (((Gear^.State = 0) and (Gear^.Hedgehog <> nil) and (Gear^.Hedgehog^.Team <> CurrentTeam)) or (Gear^.State = 1)) then |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
269 |
begin |
9764
8dc9d268330f
revert r938d1c08d0d1 in favour of putting it in the chat log. I think this addresses main concern about missing text. There've been complaints in past too about conversation in bubbles not being visible in history. If the objection is that r938d1c08d0d1 offers a more æsthetic solution, I think it should augment this, be flagged, and fix the visual issues first.
nemo
parents:
9762
diff
changeset
|
270 |
tinted:= true; |
8dc9d268330f
revert r938d1c08d0d1 in favour of putting it in the chat log. I think this addresses main concern about missing text. There've been complaints in past too about conversation in bubbles not being visible in history. If the objection is that r938d1c08d0d1 offers a more æsthetic solution, I think it should augment this, be flagged, and fix the visual issues first.
nemo
parents:
9762
diff
changeset
|
271 |
Tint($FF, $FF, $FF, $66); |
8dc9d268330f
revert r938d1c08d0d1 in favour of putting it in the chat log. I think this addresses main concern about missing text. There've been complaints in past too about conversation in bubbles not being visible in history. If the objection is that r938d1c08d0d1 offers a more æsthetic solution, I think it should augment this, be flagged, and fix the visual issues first.
nemo
parents:
9762
diff
changeset
|
272 |
DrawTextureCentered(round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, Gear^.Tex) |
8dc9d268330f
revert r938d1c08d0d1 in favour of putting it in the chat log. I think this addresses main concern about missing text. There've been complaints in past too about conversation in bubbles not being visible in history. If the objection is that r938d1c08d0d1 offers a more æsthetic solution, I think it should augment this, be flagged, and fix the visual issues first.
nemo
parents:
9762
diff
changeset
|
273 |
end |
10193
d7cd5b43588f
By request. Allow lua to make random things "talk". I'm not sure if this is a good idea, buuuut.
nemo
parents:
10121
diff
changeset
|
274 |
else if (Gear^.Tex <> nil) and (((Gear^.State = 0) and ((Gear^.Hedgehog = nil) or (Gear^.Hedgehog^.Team = CurrentTeam))) or (Gear^.State = 2)) then |
9764
8dc9d268330f
revert r938d1c08d0d1 in favour of putting it in the chat log. I think this addresses main concern about missing text. There've been complaints in past too about conversation in bubbles not being visible in history. If the objection is that r938d1c08d0d1 offers a more æsthetic solution, I think it should augment this, be flagged, and fix the visual issues first.
nemo
parents:
9762
diff
changeset
|
275 |
DrawTextureCentered(round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, Gear^.Tex); |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
276 |
end; |
6999 | 277 |
vgtSmallDamageTag: DrawTextureCentered(round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, Gear^.Tex); |
8330 | 278 |
vgtHealthTag: if Gear^.Tex <> nil then |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
279 |
begin |
8330 | 280 |
if Gear^.Frame = 0 then |
6999 | 281 |
DrawTextureCentered(round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, Gear^.Tex) |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
282 |
else |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
283 |
begin |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
284 |
SetScale(cDefaultZoomLevel); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
285 |
if Gear^.Angle = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
286 |
DrawTexture(round(Gear^.X), round(Gear^.Y), Gear^.Tex) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
287 |
else |
8330 | 288 |
DrawTexture(round(Gear^.X), round(Gear^.Y), Gear^.Tex, Gear^.Angle); |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
289 |
SetScale(zoom) |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
290 |
end |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
291 |
end; |
8330 | 292 |
vgtStraightShot: begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
293 |
if Gear^.dX < 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
294 |
i:= -1 |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
295 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
296 |
i:= 1; |
6999 | 297 |
DrawTextureRotatedF(SpritesData[TSprite(Gear^.State)].Texture, Gear^.Scale, 0, 0, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, Gear^.Frame, i, SpritesData[TSprite(Gear^.State)].Width, SpritesData[TSprite(Gear^.State)].Height, Gear^.Angle); |
5748
70d7f8e40f53
Just for fun. Flowers! Also, use a less blatant image in ammo menu.
nemo
parents:
5690
diff
changeset
|
298 |
end; |
10876 | 299 |
vgtFeather: begin |
300 |
if Gear^.FrameTicks < 255 then |
|
301 |
begin |
|
302 |
Tint($FF, $FF, $FF, Gear^.FrameTicks); |
|
303 |
tinted:= true |
|
304 |
end; |
|
305 |
DrawSpriteRotatedF(sprFeather, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, Gear^.Frame, 1, Gear^.Angle); |
|
306 |
end; |
|
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
307 |
end; |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
308 |
if (cReducedQuality and rqAntiBoom) = 0 then |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
309 |
case Gear^.Kind of |
6999 | 310 |
vgtChunk: DrawSpriteRotatedF(sprChunk, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, Gear^.Frame, 1, Gear^.Angle); |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
311 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
312 |
if (Gear^.Tint <> $FFFFFFFF) or tinted then |
9666
8dcb25112d96
- Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9285
diff
changeset
|
313 |
untint; |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
314 |
Gear:= Gear^.NextGear |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
315 |
end |
4818
202eef454354
rename "frame alternate" to "wiggle" as it's more appropriate
koda
parents:
4809
diff
changeset
|
316 |
end; |
5256
e3fada9358b0
fix water bubbles like sheepluva wanted (also code formatting)
koda
parents:
5179
diff
changeset
|
317 |
// this layer is outside the screen when stereo |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
318 |
2: begin |
6179
b529f88d37d0
Bit of an experiment with giving flakes a bit more depth. Might need to be theme flagged, or theme flakes reworked on some themes. Looks neat in stereo. Also finally use an array for the layers
nemo
parents:
6117
diff
changeset
|
319 |
Gear:= VisualGearLayers[2]; |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
320 |
while Gear <> nil do |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
321 |
begin |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
322 |
tinted:= false; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
323 |
if Gear^.Tint <> $FFFFFFFF then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
324 |
Tint(Gear^.Tint); |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
325 |
case Gear^.Kind of |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
326 |
vgtExplosion: DrawSprite(sprExplosion50, round(Gear^.X) - 32 + WorldDx, round(Gear^.Y) - 32 + WorldDy, Gear^.State); |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
327 |
vgtBigExplosion: begin |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
328 |
tinted:= true; |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
329 |
Tint($FF, $FF, $FF, round($FF * (1 - power(Gear^.Timer / 250, 4)))); |
6999 | 330 |
DrawTextureRotatedF(SpritesData[sprBigExplosion].Texture, 0.85 * (-power(2, -10 * Int(Gear^.Timer)/250) + 1) + 0.4, 0, 0, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, 0, 1, 385, 385, Gear^.Angle); |
4818
202eef454354
rename "frame alternate" to "wiggle" as it's more appropriate
koda
parents:
4809
diff
changeset
|
331 |
end; |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
332 |
end; |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
333 |
if (cReducedQuality and rqAntiBoom) = 0 then |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
334 |
case Gear^.Kind of |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
335 |
vgtExplPart: DrawSprite(sprExplPart, round(Gear^.X) + WorldDx - 16, round(Gear^.Y) + WorldDy - 16, 7 - Gear^.Frame); |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
336 |
vgtExplPart2: DrawSprite(sprExplPart2, round(Gear^.X) + WorldDx - 16, round(Gear^.Y) + WorldDy - 16, 7 - Gear^.Frame); |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
337 |
vgtSteam: DrawSprite(sprSmokeWhite, round(Gear^.X) + WorldDx - 11, round(Gear^.Y) + WorldDy - 11, 7 - Gear^.Frame); |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
338 |
vgtAmmo: begin |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
339 |
tinted:= true; |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
340 |
Tint($FF, $FF, $FF, round(Gear^.alpha * $FF)); |
6322
b310f0bc8dde
If I'm going to be arbitrary about it, might as well go for the more minimal arbitrariness
nemo
parents:
6318
diff
changeset
|
341 |
DrawTextureF(ropeIconTex, Gear^.scale, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, 0, 1, 32, 32); |
12470
c8ee50955fae
Fix vgtAmmo showing air attack icon if frame is amNothing
Wuzzy <almikes@aol.com>
parents:
12164
diff
changeset
|
342 |
if Gear^.Frame <> ord(amNothing) then |
c8ee50955fae
Fix vgtAmmo showing air attack icon if frame is amNothing
Wuzzy <almikes@aol.com>
parents:
12164
diff
changeset
|
343 |
DrawTextureF(SpritesData[sprAMAmmos].Texture, Gear^.scale * 0.90, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, Gear^.Frame - 1, 1, 32, 32); |
3115 | 344 |
end; |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
345 |
vgtShell: begin |
5256
e3fada9358b0
fix water bubbles like sheepluva wanted (also code formatting)
koda
parents:
5179
diff
changeset
|
346 |
if Gear^.FrameTicks < $FF then |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
347 |
begin |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
348 |
Tint($FF, $FF, $FF, Gear^.FrameTicks); |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
349 |
tinted:= true |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
350 |
end; |
6999 | 351 |
DrawSpriteRotatedF(sprShell, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, Gear^.Frame, 1, Gear^.Angle); |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
352 |
end; |
6999 | 353 |
vgtEgg: DrawSpriteRotatedF(sprEgg, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, Gear^.Frame, 1, Gear^.Angle); |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
354 |
vgtBeeTrace: begin |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
355 |
if Gear^.FrameTicks < $FF then |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
356 |
Tint($FF, $FF, $FF, Gear^.FrameTicks div 2) |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
357 |
else |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
358 |
Tint($FF, $FF, $FF, $80); |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
359 |
tinted:= true; |
6999 | 360 |
DrawSpriteRotatedF(sprBeeTrace, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, Gear^.Frame, 1, (RealTicks shr 4) mod cMaxAngle); |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
361 |
end; |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
362 |
vgtSmokeRing: begin |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
363 |
tinted:= true; |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
364 |
Tint($FF, $FF, $FF, round(Gear^.alpha * $FF)); |
6999 | 365 |
DrawTextureRotatedF(SpritesData[sprSmokeRing].Texture, Gear^.scale, 0, 0, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, 0, 1, 200, 200, Gear^.Angle); |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
366 |
end; |
6999 | 367 |
vgtNote: DrawSpriteRotatedF(sprNote, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, Gear^.Frame, 1, Gear^.Angle); |
368 |
vgtBulletHit: DrawSpriteRotatedF(sprBulletHit, round(Gear^.X) + WorldDx - 0, round(Gear^.Y) + WorldDy - 0, 7 - (Gear^.FrameTicks div 50), 1, Gear^.Angle); |
|
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
369 |
end; |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
370 |
case Gear^.Kind of |
10361 | 371 |
vgtFlake: begin |
12163 | 372 |
spriteData:= GetSpriteData(GetSpriteByWind(sprFlake, sprFlakeL), GetSpriteByWind(sprSDFlake, sprSDFlakeL)); |
10373 | 373 |
if speedlessFlakes then |
10362 | 374 |
DrawTextureF(spriteData^.Texture, Gear^.Scale, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame, 1, spriteData^.Width, spriteData^.Height) |
6179
b529f88d37d0
Bit of an experiment with giving flakes a bit more depth. Might need to be theme flagged, or theme flakes reworked on some themes. Looks neat in stereo. Also finally use an array for the layers
nemo
parents:
6117
diff
changeset
|
375 |
else |
10362 | 376 |
DrawTextureRotatedF(spriteData^.Texture, Gear^.Scale, 0, 0, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame, 1, spriteData^.Width, spriteData^.Height, Gear^.Angle); |
10361 | 377 |
end; |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
378 |
vgtCircle: if gear^.Angle = 1 then |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
379 |
begin |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
380 |
tmp:= Gear^.State / 100; |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
381 |
DrawTexture(round(Gear^.X-24*tmp) + WorldDx, round(Gear^.Y-24*tmp) + WorldDy, SpritesData[sprVampiric].Texture, tmp) |
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
382 |
end |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
383 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
384 |
DrawCircle(round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy, Gear^.State, Gear^.Timer); |
5585
c09f5b41644a
Break visual gears list up into 4, to avoid iterating over entire list to draw a single layer. Also fix error in tag zoom.
nemo
parents:
5583
diff
changeset
|
385 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
386 |
if (Gear^.Tint <> $FFFFFFFF) or tinted then |
9666
8dcb25112d96
- Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9285
diff
changeset
|
387 |
untint; |
6302
db8bdbb34e03
Spread flakes out over 5 layers now (far back, mid distance, just behind land, just in front of lands and hog, near distance). Spread clouds out over 3 layers (far back, mid distance, just behind land). Add a flatten clouds option, use
nemo
parents:
6291
diff
changeset
|
388 |
Gear:= Gear^.NextGear |
db8bdbb34e03
Spread flakes out over 5 layers now (far back, mid distance, just behind land, just in front of lands and hog, near distance). Spread clouds out over 3 layers (far back, mid distance, just behind land). Add a flatten clouds option, use
nemo
parents:
6291
diff
changeset
|
389 |
end |
db8bdbb34e03
Spread flakes out over 5 layers now (far back, mid distance, just behind land, just in front of lands and hog, near distance). Spread clouds out over 3 layers (far back, mid distance, just behind land). Add a flatten clouds option, use
nemo
parents:
6291
diff
changeset
|
390 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
391 |
// this layer is half-way between the screen plane (depth = 0) when in stereo, and the land |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
392 |
4: begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
393 |
Gear:= VisualGearLayers[4]; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
394 |
while Gear <> nil do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
395 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
396 |
if Gear^.Tint <> $FFFFFFFF then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
397 |
Tint(Gear^.Tint); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
398 |
case Gear^.Kind of |
10361 | 399 |
vgtCloud: begin |
12163 | 400 |
spriteData:= GetSpriteData(GetSpriteByWind(sprCloud, sprCloudL), GetSpriteByWind(sprSDCloud, sprSDCloudL)); |
10361 | 401 |
DrawTextureF(spriteData^.Texture, Gear^.Scale, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame, 1, spriteData^.Width, spriteData^.Height); |
402 |
end; |
|
403 |
vgtFlake: begin |
|
12163 | 404 |
spriteData:= GetSpriteData(GetSpriteByWind(sprFlake, sprFlakeL), GetSpriteByWind(sprSDFlake, sprSDFlakeL)); |
10373 | 405 |
if speedlessFlakes then |
10362 | 406 |
DrawTextureF(spriteData^.Texture, Gear^.Scale, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame, 1, spriteData^.Width, spriteData^.Height) |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
407 |
else |
10362 | 408 |
DrawTextureRotatedF(spriteData^.Texture, Gear^.Scale, 0, 0, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame, 1, spriteData^.Width, spriteData^.Height, Gear^.Angle); |
10361 | 409 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
410 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
411 |
if (Gear^.Tint <> $FFFFFFFF) then |
9666
8dcb25112d96
- Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9285
diff
changeset
|
412 |
untint; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
413 |
Gear:= Gear^.NextGear |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
414 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
415 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
416 |
// this layer is on the screen plane (depth = 0) when stereo, but just behind the land |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
417 |
5: begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
418 |
Gear:= VisualGearLayers[5]; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
419 |
while Gear <> nil do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
420 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
421 |
if Gear^.Tint <> $FFFFFFFF then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
422 |
Tint(Gear^.Tint); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
423 |
case Gear^.Kind of |
10361 | 424 |
vgtCloud: begin |
12164 | 425 |
sprite:= GetSpriteByWind(GetSprite(sprCloud, sprSDCloud), GetSprite(sprCloudL, sprSDCloudL)); |
10361 | 426 |
DrawSprite(sprite, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame); |
427 |
end; |
|
428 |
vgtFlake: begin |
|
12164 | 429 |
sprite:= GetSpriteByWind(GetSprite(sprFlake, sprSDFlake), GetSprite(sprFlakeL, sprSDFlakeL)); |
10373 | 430 |
if speedlessFlakes then |
10361 | 431 |
DrawSprite(sprite, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame) |
432 |
else |
|
433 |
DrawSpriteRotatedF(sprite, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame, 1, Gear^.Angle); |
|
434 |
end; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
435 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
436 |
if (Gear^.Tint <> $FFFFFFFF) then |
9666
8dcb25112d96
- Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9285
diff
changeset
|
437 |
untint; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
438 |
Gear:= Gear^.NextGear |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
439 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
440 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
441 |
// this layer is on the screen plane (depth = 0) when stereo, but just in front of the land |
6302
db8bdbb34e03
Spread flakes out over 5 layers now (far back, mid distance, just behind land, just in front of lands and hog, near distance). Spread clouds out over 3 layers (far back, mid distance, just behind land). Add a flatten clouds option, use
nemo
parents:
6291
diff
changeset
|
442 |
6: begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
443 |
Gear:= VisualGearLayers[6]; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
444 |
while Gear <> nil do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
445 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
446 |
if Gear^.Tint <> $FFFFFFFF then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
447 |
Tint(Gear^.Tint); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
448 |
case Gear^.Kind of |
10361 | 449 |
vgtFlake: begin |
12163 | 450 |
sprite:= GetSpriteByWind(GetSprite(sprFlake, sprSDFlake), GetSprite(sprFlakeL, sprSDFlakeL)); |
10373 | 451 |
if speedlessFlakes then |
10361 | 452 |
DrawSprite(sprite, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame) |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
453 |
else |
10361 | 454 |
DrawSpriteRotatedF(sprite, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame, 1, Gear^.Angle) |
455 |
end; |
|
10251
a3b42e81803c
collision indicator on failed girder placement (especially useful with rubberband I guess). still needs some tweaks but I am going to bed now :P
sheepluva
parents:
10193
diff
changeset
|
456 |
vgtNoPlaceWarn: |
a3b42e81803c
collision indicator on failed girder placement (especially useful with rubberband I guess). still needs some tweaks but I am going to bed now :P
sheepluva
parents:
10193
diff
changeset
|
457 |
DrawTexture(round(Gear^.X) + WorldDx - round(Gear^.Tex^.w * Gear^.Scale) div 2, round(Gear^.Y) + WorldDy - round(Gear^.Tex^.h * Gear^.Scale) div 2, Gear^.Tex, Gear^.Scale); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
458 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
459 |
if (Gear^.Tint <> $FFFFFFFF) then |
9666
8dcb25112d96
- Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9285
diff
changeset
|
460 |
untint; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
461 |
Gear:= Gear^.NextGear |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
462 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
463 |
end; |
4452 | 464 |
end; |
802
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
465 |
end; |
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
466 |
|
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
467 |
procedure AddClouds; |
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
468 |
var i: LongInt; |
803 | 469 |
begin |
1132 | 470 |
for i:= 0 to cCloudsNumber - 1 do |
5179
8d64dcb566ea
Fix "Mixing signed expressions and longwords gives a 64bit result" warnings
unc0rr
parents:
5151
diff
changeset
|
471 |
AddVisualGear(cLeftScreenBorder + i * LongInt(cScreenSpace div (cCloudsNumber + 1)), LAND_HEIGHT-1184, vgtCloud) |
802
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
472 |
end; |
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
473 |
|
4792
68f9b331014a
sudden death changes: only change visual bit on health decrease and support for water transparancy change and clouds number change
Henek
parents:
4782
diff
changeset
|
474 |
procedure ChangeToSDClouds; |
12707
0dfb49261cab
Fix failure to update all cloud layers properly when entering Sudden Death
Wuzzy <almikes@aol.com>
parents:
12470
diff
changeset
|
475 |
var i, j: LongInt; |
4792
68f9b331014a
sudden death changes: only change visual bit on health decrease and support for water transparancy change and clouds number change
Henek
parents:
4782
diff
changeset
|
476 |
vg, tmp: PVisualGear; |
68f9b331014a
sudden death changes: only change visual bit on health decrease and support for water transparancy change and clouds number change
Henek
parents:
4782
diff
changeset
|
477 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
478 |
if cCloudsNumber = cSDCloudsNumber then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
479 |
exit; |
12707
0dfb49261cab
Fix failure to update all cloud layers properly when entering Sudden Death
Wuzzy <almikes@aol.com>
parents:
12470
diff
changeset
|
480 |
for i:= 0 to 6 do |
0dfb49261cab
Fix failure to update all cloud layers properly when entering Sudden Death
Wuzzy <almikes@aol.com>
parents:
12470
diff
changeset
|
481 |
begin |
0dfb49261cab
Fix failure to update all cloud layers properly when entering Sudden Death
Wuzzy <almikes@aol.com>
parents:
12470
diff
changeset
|
482 |
vg:= VisualGearLayers[i]; |
0dfb49261cab
Fix failure to update all cloud layers properly when entering Sudden Death
Wuzzy <almikes@aol.com>
parents:
12470
diff
changeset
|
483 |
while vg <> nil do |
0dfb49261cab
Fix failure to update all cloud layers properly when entering Sudden Death
Wuzzy <almikes@aol.com>
parents:
12470
diff
changeset
|
484 |
if vg^.Kind = vgtCloud then |
0dfb49261cab
Fix failure to update all cloud layers properly when entering Sudden Death
Wuzzy <almikes@aol.com>
parents:
12470
diff
changeset
|
485 |
begin |
0dfb49261cab
Fix failure to update all cloud layers properly when entering Sudden Death
Wuzzy <almikes@aol.com>
parents:
12470
diff
changeset
|
486 |
tmp:= vg^.NextGear; |
0dfb49261cab
Fix failure to update all cloud layers properly when entering Sudden Death
Wuzzy <almikes@aol.com>
parents:
12470
diff
changeset
|
487 |
DeleteVisualGear(vg); |
0dfb49261cab
Fix failure to update all cloud layers properly when entering Sudden Death
Wuzzy <almikes@aol.com>
parents:
12470
diff
changeset
|
488 |
vg:= tmp |
0dfb49261cab
Fix failure to update all cloud layers properly when entering Sudden Death
Wuzzy <almikes@aol.com>
parents:
12470
diff
changeset
|
489 |
end |
0dfb49261cab
Fix failure to update all cloud layers properly when entering Sudden Death
Wuzzy <almikes@aol.com>
parents:
12470
diff
changeset
|
490 |
else vg:= vg^.NextGear; |
0dfb49261cab
Fix failure to update all cloud layers properly when entering Sudden Death
Wuzzy <almikes@aol.com>
parents:
12470
diff
changeset
|
491 |
for j:= 0 to cSDCloudsNumber - 1 do |
0dfb49261cab
Fix failure to update all cloud layers properly when entering Sudden Death
Wuzzy <almikes@aol.com>
parents:
12470
diff
changeset
|
492 |
AddVisualGear(cLeftScreenBorder + j * LongInt(cScreenSpace div (cSDCloudsNumber + 1)), LAND_HEIGHT-1184, vgtCloud) |
0dfb49261cab
Fix failure to update all cloud layers properly when entering Sudden Death
Wuzzy <almikes@aol.com>
parents:
12470
diff
changeset
|
493 |
end; |
4792
68f9b331014a
sudden death changes: only change visual bit on health decrease and support for water transparancy change and clouds number change
Henek
parents:
4782
diff
changeset
|
494 |
end; |
68f9b331014a
sudden death changes: only change visual bit on health decrease and support for water transparancy change and clouds number change
Henek
parents:
4782
diff
changeset
|
495 |
|
4806
48c1a395f0a7
added flake configuration also in sudden death and SDClouds for underwater
Henek
parents:
4792
diff
changeset
|
496 |
procedure AddFlakes; |
48c1a395f0a7
added flake configuration also in sudden death and SDClouds for underwater
Henek
parents:
4792
diff
changeset
|
497 |
var i: LongInt; |
48c1a395f0a7
added flake configuration also in sudden death and SDClouds for underwater
Henek
parents:
4792
diff
changeset
|
498 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
499 |
if (cReducedQuality and rqKillFlakes) <> 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
500 |
exit; |
4806
48c1a395f0a7
added flake configuration also in sudden death and SDClouds for underwater
Henek
parents:
4792
diff
changeset
|
501 |
|
9768
08799c901a42
Add rubber utility. Graphics are still incomplete. Also flag snow/ice in theme config.
nemo
parents:
9764
diff
changeset
|
502 |
if hasBorder or (not cSnow) then |
7543
a0dc770538e1
Poor visual gear value in theme now bears little resemblance to the number of gears actually spawned. But, it certainly shouldn't be related to LAND_WIDTH.
nemo
parents:
7420
diff
changeset
|
503 |
for i:= 0 to Pred(vobCount * cScreenSpace div 4096) do |
4806
48c1a395f0a7
added flake configuration also in sudden death and SDClouds for underwater
Henek
parents:
4792
diff
changeset
|
504 |
AddVisualGear(cLeftScreenBorder + random(cScreenSpace), random(1024+200) - 100 + LAND_HEIGHT, vgtFlake) |
48c1a395f0a7
added flake configuration also in sudden death and SDClouds for underwater
Henek
parents:
4792
diff
changeset
|
505 |
else |
7543
a0dc770538e1
Poor visual gear value in theme now bears little resemblance to the number of gears actually spawned. But, it certainly shouldn't be related to LAND_WIDTH.
nemo
parents:
7420
diff
changeset
|
506 |
for i:= 0 to Pred((vobCount * cScreenSpace div 4096) div 3) do |
4806
48c1a395f0a7
added flake configuration also in sudden death and SDClouds for underwater
Henek
parents:
4792
diff
changeset
|
507 |
AddVisualGear(cLeftScreenBorder + random(cScreenSpace), random(1024+200) - 100 + LAND_HEIGHT, vgtFlake); |
48c1a395f0a7
added flake configuration also in sudden death and SDClouds for underwater
Henek
parents:
4792
diff
changeset
|
508 |
end; |
48c1a395f0a7
added flake configuration also in sudden death and SDClouds for underwater
Henek
parents:
4792
diff
changeset
|
509 |
|
48c1a395f0a7
added flake configuration also in sudden death and SDClouds for underwater
Henek
parents:
4792
diff
changeset
|
510 |
procedure ChangeToSDFlakes; |
48c1a395f0a7
added flake configuration also in sudden death and SDClouds for underwater
Henek
parents:
4792
diff
changeset
|
511 |
var i: LongInt; |
48c1a395f0a7
added flake configuration also in sudden death and SDClouds for underwater
Henek
parents:
4792
diff
changeset
|
512 |
vg, tmp: PVisualGear; |
48c1a395f0a7
added flake configuration also in sudden death and SDClouds for underwater
Henek
parents:
4792
diff
changeset
|
513 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
514 |
if (cReducedQuality and rqKillFlakes) <> 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
515 |
exit; |
13053
9dd724e8d620
Fix SD flakes attributes not set properly when SD flake count = normal flake count
Wuzzy <Wuzzy2@mail.ru>
parents:
12707
diff
changeset
|
516 |
if (vobCount = vobSDCount) and (vobFrameTicks = vobSDFrameTicks) and |
9dd724e8d620
Fix SD flakes attributes not set properly when SD flake count = normal flake count
Wuzzy <Wuzzy2@mail.ru>
parents:
12707
diff
changeset
|
517 |
(vobFramesCount = vobSDFramesCount) and (vobVelocity = vobSDVelocity) and |
9dd724e8d620
Fix SD flakes attributes not set properly when SD flake count = normal flake count
Wuzzy <Wuzzy2@mail.ru>
parents:
12707
diff
changeset
|
518 |
(vobFallSpeed = vobSDFallSpeed) then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6553
diff
changeset
|
519 |
exit; |
6302
db8bdbb34e03
Spread flakes out over 5 layers now (far back, mid distance, just behind land, just in front of lands and hog, near distance). Spread clouds out over 3 layers (far back, mid distance, just behind land). Add a flatten clouds option, use
nemo
parents:
6291
diff
changeset
|
520 |
for i:= 0 to 6 do |
6179
b529f88d37d0
Bit of an experiment with giving flakes a bit more depth. Might need to be theme flagged, or theme flakes reworked on some themes. Looks neat in stereo. Also finally use an array for the layers
nemo
parents:
6117
diff
changeset
|
521 |
begin |
b529f88d37d0
Bit of an experiment with giving flakes a bit more depth. Might need to be theme flagged, or theme flakes reworked on some themes. Looks neat in stereo. Also finally use an array for the layers
nemo
parents:
6117
diff
changeset
|
522 |
vg:= VisualGearLayers[i]; |
b529f88d37d0
Bit of an experiment with giving flakes a bit more depth. Might need to be theme flagged, or theme flakes reworked on some themes. Looks neat in stereo. Also finally use an array for the layers
nemo
parents:
6117
diff
changeset
|
523 |
while vg <> nil do |
b529f88d37d0
Bit of an experiment with giving flakes a bit more depth. Might need to be theme flagged, or theme flakes reworked on some themes. Looks neat in stereo. Also finally use an array for the layers
nemo
parents:
6117
diff
changeset
|
524 |
if vg^.Kind = vgtFlake then |
10658 | 525 |
begin |
526 |
tmp:= vg^.NextGear; |
|
527 |
DeleteVisualGear(vg); |
|
528 |
vg:= tmp |
|
529 |
end |
|
6179
b529f88d37d0
Bit of an experiment with giving flakes a bit more depth. Might need to be theme flagged, or theme flakes reworked on some themes. Looks neat in stereo. Also finally use an array for the layers
nemo
parents:
6117
diff
changeset
|
530 |
else vg:= vg^.NextGear; |
b529f88d37d0
Bit of an experiment with giving flakes a bit more depth. Might need to be theme flagged, or theme flakes reworked on some themes. Looks neat in stereo. Also finally use an array for the layers
nemo
parents:
6117
diff
changeset
|
531 |
end; |
9768
08799c901a42
Add rubber utility. Graphics are still incomplete. Also flag snow/ice in theme config.
nemo
parents:
9764
diff
changeset
|
532 |
if hasBorder or (not cSnow) then |
7822
61ff669d610f
missed this one when fixing regular flakes. issue #444
nemo
parents:
7615
diff
changeset
|
533 |
for i:= 0 to Pred(vobSDCount * cScreenSpace div 4096) do |
4806
48c1a395f0a7
added flake configuration also in sudden death and SDClouds for underwater
Henek
parents:
4792
diff
changeset
|
534 |
AddVisualGear(cLeftScreenBorder + random(cScreenSpace), random(1024+200) - 100 + LAND_HEIGHT, vgtFlake) |
48c1a395f0a7
added flake configuration also in sudden death and SDClouds for underwater
Henek
parents:
4792
diff
changeset
|
535 |
else |
7822
61ff669d610f
missed this one when fixing regular flakes. issue #444
nemo
parents:
7615
diff
changeset
|
536 |
for i:= 0 to Pred((vobSDCount * cScreenSpace div 4096) div 3) do |
4806
48c1a395f0a7
added flake configuration also in sudden death and SDClouds for underwater
Henek
parents:
4792
diff
changeset
|
537 |
AddVisualGear(cLeftScreenBorder + random(cScreenSpace), random(1024+200) - 100 + LAND_HEIGHT, vgtFlake); |
48c1a395f0a7
added flake configuration also in sudden death and SDClouds for underwater
Henek
parents:
4792
diff
changeset
|
538 |
end; |
48c1a395f0a7
added flake configuration also in sudden death and SDClouds for underwater
Henek
parents:
4792
diff
changeset
|
539 |
|
3038 | 540 |
procedure initModule; |
6179
b529f88d37d0
Bit of an experiment with giving flakes a bit more depth. Might need to be theme flagged, or theme flakes reworked on some themes. Looks neat in stereo. Also finally use an array for the layers
nemo
parents:
6117
diff
changeset
|
541 |
var i: LongWord; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
542 |
begin |
6982 | 543 |
VGCounter:= 0; |
6302
db8bdbb34e03
Spread flakes out over 5 layers now (far back, mid distance, just behind land, just in front of lands and hog, near distance). Spread clouds out over 3 layers (far back, mid distance, just behind land). Add a flatten clouds option, use
nemo
parents:
6291
diff
changeset
|
544 |
for i:= 0 to 6 do |
6179
b529f88d37d0
Bit of an experiment with giving flakes a bit more depth. Might need to be theme flagged, or theme flakes reworked on some themes. Looks neat in stereo. Also finally use an array for the layers
nemo
parents:
6117
diff
changeset
|
545 |
VisualGearLayers[i]:= nil; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2695
diff
changeset
|
546 |
end; |
802
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
547 |
|
3038 | 548 |
procedure freeModule; |
6179
b529f88d37d0
Bit of an experiment with giving flakes a bit more depth. Might need to be theme flagged, or theme flakes reworked on some themes. Looks neat in stereo. Also finally use an array for the layers
nemo
parents:
6117
diff
changeset
|
549 |
var i: LongWord; |
2715
0e4e0db79e2a
Free up some unfreed memory. Needed for Koda's iphone lib work
nemo
parents:
2713
diff
changeset
|
550 |
begin |
6982 | 551 |
VGCounter:= 0; |
6302
db8bdbb34e03
Spread flakes out over 5 layers now (far back, mid distance, just behind land, just in front of lands and hog, near distance). Spread clouds out over 3 layers (far back, mid distance, just behind land). Add a flatten clouds option, use
nemo
parents:
6291
diff
changeset
|
552 |
for i:= 0 to 6 do |
6179
b529f88d37d0
Bit of an experiment with giving flakes a bit more depth. Might need to be theme flagged, or theme flakes reworked on some themes. Looks neat in stereo. Also finally use an array for the layers
nemo
parents:
6117
diff
changeset
|
553 |
while VisualGearLayers[i] <> nil do DeleteVisualGear(VisualGearLayers[i]); |
2715
0e4e0db79e2a
Free up some unfreed memory. Needed for Koda's iphone lib work
nemo
parents:
2713
diff
changeset
|
554 |
end; |
802
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
555 |
|
ed5450a89b96
Start implementing 'visual gears' - gears, that don't need to be synchronized (clouds and flakes)
unc0rr
parents:
diff
changeset
|
556 |
end. |