author  antonc27 <antonc27@mail.ru> 
Sat, 08 Aug 2015 22:02:31 +0200  
branch  iosrevival 
changeset 11090  874e477700d5 
parent 11000  b1c8027cc8f7 
child 11151  5c40c65b619d 
permissions  rwrr 
4  1 
(* 
1066  2 
* Hedgewars, a free turn based strategy game 
9998  3 
* Copyright (c) 20042014 Andrey Korotaev <unC0Rr@gmail.com> 
4  4 
* 
183  5 
* This program is free software; you can redistribute it and/or modify 
6 
* it under the terms of the GNU General Public License as published by 

7 
* the Free Software Foundation; version 2 of the License 

4  8 
* 
183  9 
* This program is distributed in the hope that it will be useful, 
10 
* but WITHOUT ANY WARRANTY; without even the implied warranty of 

11 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 

12 
* GNU General Public License for more details. 

4  13 
* 
183  14 
* You should have received a copy of the GNU General Public License 
15 
* along with this program; if not, write to the Free Software 

10108
c68cf030eded
update FSF address. note: two sdl include files (by Sam Lantinga) still have the old FSF address in their copyright  but I ain't gonna touch their copyright headers
sheepluva
parents:
10080
diff
changeset

16 
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 021101301 USA 
4  17 
*) 
18 

2630  19 
{$INCLUDE "options.inc"} 
20 

4  21 
unit uWorld; 
22 
interface 

6622  23 
uses SDLh, uGears, uConsts, uFloat, uRandom, uTypes, uRenderUtils; 
3697  24 

3038  25 
procedure initModule; 
26 
procedure freeModule; 

2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2713
diff
changeset

27 

b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2713
diff
changeset

28 
procedure InitWorld; 
6394
f0a9042e7387
yay, finally osx (and likely windows) fullscreen switch works like on linux! ALL textures had to be destroyed and recreated only after the new window got created. In other news, the new window must be cleaned with glClear to skip a first frame of garbage and AddProgress is only called the first time.
koda
parents:
6380
diff
changeset

29 
procedure ResetWorldTex; 
f0a9042e7387
yay, finally osx (and likely windows) fullscreen switch works like on linux! ALL textures had to be destroyed and recreated only after the new window got created. In other news, the new window must be cleaned with glClear to skip a first frame of garbage and AddProgress is only called the first time.
koda
parents:
6380
diff
changeset

30 

2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2713
diff
changeset

31 
procedure DrawWorld(Lag: LongInt); 
3692  32 
procedure DrawWorldStereo(Lag: LongInt; RM: TRenderMode); 
10122
cefede760264
Revert 88929358d2e1 in favor of ansistrings implementation in pas2c
unc0rr
parents:
10120
diff
changeset

33 
procedure ShowMission(caption, subcaption, text: ansistring; icon, time : LongInt); 
2786  34 
procedure HideMission; 
6011
519f8a58c021
Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents:
5862
diff
changeset

35 
procedure ShakeCamera(amount: LongInt); 
5682
06d5f561f772
some camera adjustments (should also fix cam flickering on lowerst res)
sheepluva
parents:
5675
diff
changeset

36 
procedure InitCameraBorders; 
6682  37 
procedure InitTouchInterface; 
7023  38 
procedure SetUtilityWidgetState(ammoType: TAmmoType); 
6688  39 
procedure animateWidget(widget: POnScreenWidget; fade, showWidget: boolean); 
3638
33ee433749ba
touch overlay reworked, improvements to zoom and confirmation
koda
parents:
3629
diff
changeset

40 
procedure MoveCamera; 
5521  41 
procedure onFocusStateChanged; 
10392  42 
procedure updateCursorVisibility; 
4  43 

44 
implementation 

4359  45 
uses 
7721  46 
uStore 
47 
, uMisc 

48 
, uIO 

49 
, uLocale 

50 
, uSound 

51 
, uAmmos 

52 
, uVisualGears 

53 
, uChat 

54 
, uLandTexture 

55 
, uVariables 

56 
, uUtils 

57 
, uTextures 

58 
, uRender 

59 
, uCaptions 

60 
, uCursor 

61 
, uCommands 

9720
453a1c29b7e4
Animate hedgehogs healths inside team health bar. Proper animation for the case when max team health grows is lost though.
unc0rr
parents:
9693
diff
changeset

62 
, uTeams 
453a1c29b7e4
Animate hedgehogs healths inside team health bar. Proper animation for the case when max team health grows is lost though.
unc0rr
parents:
9693
diff
changeset

63 
{$IFDEF USE_VIDEO_RECORDING} 
7721  64 
, uVideoRec 
9720
453a1c29b7e4
Animate hedgehogs healths inside team health bar. Proper animation for the case when max team health grows is lost though.
unc0rr
parents:
9693
diff
changeset

65 
{$ENDIF} 
4359  66 
; 
4  67 

10331  68 
var AMShiftTargetX, AMShiftTargetY, AMShiftX, AMShiftY, SlotsNum: LongInt; 
6796
3e89dbdc7db9
You can now change AMAnimType to enable the animation through the x/y axis and alpha for example
Xeli
parents:
6795
diff
changeset

69 
AMAnimStartTime, AMState : LongInt; 
3e89dbdc7db9
You can now change AMAnimType to enable the animation through the x/y axis and alpha for example
Xeli
parents:
6795
diff
changeset

70 
AMAnimState: Single; 
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2682
diff
changeset

71 
tmpSurface: PSDL_Surface; 
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2682
diff
changeset

72 
fpsTexture: PTexture; 
2850
f6f8db825ce7
A little clock for convenience in finding things in demos
nemo
parents:
2839
diff
changeset

73 
timeTexture: PTexture; 
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2713
diff
changeset

74 
FPS: Longword; 
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2713
diff
changeset

75 
CountTicks: Longword; 
8773  76 
prevPoint{, prevTargetPoint}: TPoint; 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2931
diff
changeset

77 
amSel: TAmmoType = amNothing; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2931
diff
changeset

78 
missionTex: PTexture; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2931
diff
changeset

79 
missionTimer: LongInt; 
7027  80 
isFirstFrame: boolean; 
7028  81 
AMAnimType: LongInt; 
7180  82 
recTexture: PTexture; 
8145
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
8138
diff
changeset

83 
AmmoMenuTex : PTexture; 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
8138
diff
changeset

84 
HorizontOffset: LongInt; 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
8138
diff
changeset

85 
cOffsetY: LongInt; 
9557  86 
WorldEnd, WorldFade : array[0..3] of HwColor4f; 
3692  87 

4816
c2575faeac3d
use a different depth for different layers (land, water, explosions)
koda
parents:
4812
diff
changeset

88 
const cStereo_Sky = 0.0500; 
c2575faeac3d
use a different depth for different layers (land, water, explosions)
koda
parents:
4812
diff
changeset

89 
cStereo_Horizon = 0.0250; 
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:
6296
diff
changeset

90 
cStereo_MidDistance = 0.0175; 
4816
c2575faeac3d
use a different depth for different layers (land, water, explosions)
koda
parents:
4812
diff
changeset

91 
cStereo_Water_distant = 0.0125; 
c2575faeac3d
use a different depth for different layers (land, water, explosions)
koda
parents:
4812
diff
changeset

92 
cStereo_Land = 0.0075; 
c2575faeac3d
use a different depth for different layers (land, water, explosions)
koda
parents:
4812
diff
changeset

93 
cStereo_Water_near = 0.0025; 
6289
95ffd59d0f4a
Increase rarity of near flakes (don't want them intruding in game much). Also fix stereo. Near flakes were being drawn far.
nemo
parents:
6276
diff
changeset

94 
cStereo_Outside = 0.0400; 
4  95 

8145
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
8138
diff
changeset

96 
AMAnimDuration = 200; 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
8138
diff
changeset

97 
AMHidden = 0;//AMState values 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
8138
diff
changeset

98 
AMShowingUp = 1; 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
8138
diff
changeset

99 
AMShowing = 2; 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
8138
diff
changeset

100 
AMHiding = 3; 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
8138
diff
changeset

101 

6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
8138
diff
changeset

102 
AMTypeMaskX = $00000001; 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
8138
diff
changeset

103 
AMTypeMaskY = $00000002; 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
8138
diff
changeset

104 
AMTypeMaskAlpha = $00000004; 
8370  105 
//AMTypeMaskSlide = $00000008; 
8145
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
8138
diff
changeset

106 

6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
8138
diff
changeset

107 
{$IFDEF MOBILE} 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
8138
diff
changeset

108 
AMSlotSize = 48; 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
8138
diff
changeset

109 
{$ELSE} 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
8138
diff
changeset

110 
AMSlotSize = 32; 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
8138
diff
changeset

111 
{$ENDIF} 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
8138
diff
changeset

112 
AMSlotPadding = (AMSlotSize  32) shr 1; 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
8138
diff
changeset

113 

6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
8138
diff
changeset

114 
cSendCursorPosTime = 50; 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
8138
diff
changeset

115 
cCursorEdgesDist = 100; 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
8138
diff
changeset

116 

6492  117 
// helper functions to create the goal/game mode string 
118 
function AddGoal(s: ansistring; gf: longword; si: TGoalStrId; i: LongInt): ansistring; 

119 
var t: ansistring; 

120 
begin 

10080  121 
{$IFNDEF PAS2C} 
6492  122 
if (GameFlags and gf) <> 0 then 
123 
begin 

124 
t:= inttostr(i); 

7069  125 
s:= s + FormatA(trgoal[si], t) + '' 
6492  126 
end; 
10080  127 
{$ENDIF} 
6492  128 
AddGoal:= s; 
129 
end; 

130 

131 
function AddGoal(s: ansistring; gf: longword; si: TGoalStrId): ansistring; 

132 
begin 

10080  133 
{$IFNDEF PAS2C} 
6492  134 
if (GameFlags and gf) <> 0 then 
135 
s:= s + trgoal[si] + ''; 

10080  136 
{$ENDIF} 
6492  137 
AddGoal:= s; 
138 
end; 

139 

4  140 
procedure InitWorld; 
2704
51cda17b7c3b
Rolling random numbers before land is generated is bad, m'kay? InitWorld probably not the best place for it.
nemo
parents:
2699
diff
changeset

141 
var i, t: LongInt; 
51cda17b7c3b
Rolling random numbers before land is generated is bad, m'kay? InitWorld probably not the best place for it.
nemo
parents:
2699
diff
changeset

142 
cp: PClan; 
2863  143 
g: ansistring; 
4  144 
begin 
3764  145 
missionTimer:= 0; 
2786  146 

2704
51cda17b7c3b
Rolling random numbers before land is generated is bad, m'kay? InitWorld probably not the best place for it.
nemo
parents:
2699
diff
changeset

147 
if (GameFlags and gfRandomOrder) <> 0 then // shuffle them up a bit 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

148 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

149 
for i:= 0 to ClansCount * 4 do 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

150 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

151 
t:= GetRandom(ClansCount); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

152 
if t <> 0 then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

153 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

154 
cp:= ClansArray[0]; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

155 
ClansArray[0]:= ClansArray[t]; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

156 
ClansArray[t]:= cp; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

157 
ClansArray[t]^.ClanIndex:= t; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

158 
ClansArray[0]^.ClanIndex:= 0; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

159 
if (LocalClan = t) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

160 
LocalClan:= 0 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

161 
else if (LocalClan = 0) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

162 
LocalClan:= t 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

163 
end; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

164 
end; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

165 
CurrentTeam:= ClansArray[0]^.Teams[0]; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

166 
end; 
2704
51cda17b7c3b
Rolling random numbers before land is generated is bad, m'kay? InitWorld probably not the best place for it.
nemo
parents:
2699
diff
changeset

167 

2908  168 
// if special game flags/settings are changed, add them to the game mode notice window and then show it 
2863  169 
g:= ''; // no text/things to note yet 
2908  170 

4883
7cddc9201a1d
added dummy for tardis and ugly icons for tardis and structure
Henek
parents:
4850
diff
changeset

171 
// add custom goals from lua script if there are any 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

172 
if LuaGoals <> '' then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

173 
g:= LuaGoals + ''; 
4883
7cddc9201a1d
added dummy for tardis and ugly icons for tardis and structure
Henek
parents:
4850
diff
changeset

174 

2958  175 
// check different game flags (goals/game modes first for now) 
176 
g:= AddGoal(g, gfKing, gidKing); // king? 

5022
d2a2f6c9b236
some final work and buggfix for Tag Team, it is now playable
Henek
parents:
4976
diff
changeset

177 
g:= AddGoal(g, gfTagTeam, gidTagTeam); // tag team mode? 
2958  178 

179 
// other important flags 

180 
g:= AddGoal(g, gfForts, gidForts); // forts? 

181 
g:= AddGoal(g, gfLowGravity, gidLowGravity); // low gravity? 

182 
g:= AddGoal(g, gfInvulnerable, gidInvulnerable); // invulnerability? 

183 
g:= AddGoal(g, gfVampiric, gidVampiric); // vampirism? 

184 
g:= AddGoal(g, gfKarma, gidKarma); // karma? 

185 
g:= AddGoal(g, gfPlaceHog, gidPlaceHog); // placement? 

186 
g:= AddGoal(g, gfArtillery, gidArtillery); // artillery? 

187 
g:= AddGoal(g, gfSolidLand, gidSolidLand); // solid land? 

188 
g:= AddGoal(g, gfSharedAmmo, gidSharedAmmo); // shared ammo? 

4132  189 
g:= AddGoal(g, gfResetHealth, gidResetHealth); 
190 
g:= AddGoal(g, gfAISurvival, gidAISurvival); 

191 
g:= AddGoal(g, gfInfAttack, gidInfAttack); 

192 
g:= AddGoal(g, gfResetWeps, gidResetWeps); 

193 
g:= AddGoal(g, gfPerHogAmmo, gidPerHogAmmo); 

2958  194 

2908  195 
// modified damage modificator? 
196 
if cDamagePercent <> 100 then 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2931
diff
changeset

197 
g:= AddGoal(g, gfAny, gidDamageModifier, cDamagePercent); 
2908  198 

3107  199 
// fade in 
200 
ScreenFade:= sfFromBlack; 

201 
ScreenFadeValue:= sfMax; 

202 
ScreenFadeSpeed:= 1; 

203 

2908  204 
// modified mine timers? 
4482  205 
if cMinesTime <> 3000 then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2931
diff
changeset

206 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2931
diff
changeset

207 
if cMinesTime = 0 then 
4003
ca0600ab38bf
disable gfMines and update variable names (landadds > minesnum, cLandAdditions > cLandMines)
koda
parents:
3976
diff
changeset

208 
g:= AddGoal(g, gfAny, gidNoMineTimer) 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2931
diff
changeset

209 
else if cMinesTime < 0 then 
4003
ca0600ab38bf
disable gfMines and update variable names (landadds > minesnum, cLandAdditions > cLandMines)
koda
parents:
3976
diff
changeset

210 
g:= AddGoal(g, gfAny, gidRandomMineTimer) 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2931
diff
changeset

211 
else 
4482  212 
g:= AddGoal(g, gfAny, gidMineTimer, cMinesTime div 1000); 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2931
diff
changeset

213 
end; 
2908  214 

2863  215 
// if the string has been set, show it for (default timeframe) seconds 
10120  216 
if length(g) > 0 then 
10122
cefede760264
Revert 88929358d2e1 in favor of ansistrings implementation in pas2c
unc0rr
parents:
10120
diff
changeset

217 
ShowMission(trgoal[gidCaption], trgoal[gidSubCaption], g, 1, 0); 
2863  218 

10331  219 
//cWaveWidth:= SpritesData[sprWater].Width; 
2268
053eb81e60ee
little experiment to see if this improve appearance of laser/ufo/cake/laser guided missile  of course, can't actually see it until unc0rr restores waves
nemo
parents:
2226
diff
changeset

220 
//cWaveHeight:= SpritesData[sprWater].Height; 
053eb81e60ee
little experiment to see if this improve appearance of laser/ufo/cake/laser guided missile  of course, can't actually see it until unc0rr restores waves
nemo
parents:
2226
diff
changeset

221 
cWaveHeight:= 32; 
2292
87af4ad0ec98
New waves rendering procedure based on using texture coodrinates > 1.0
unc0rr
parents:
2290
diff
changeset

222 

5682
06d5f561f772
some camera adjustments (should also fix cam flickering on lowerst res)
sheepluva
parents:
5675
diff
changeset

223 
InitCameraBorders(); 
5191
c7000a6b397b
 Implement a thin wrapper over real cursor, which eliminates need in SDL_WarpMouse outside game window
unc0rr
parents:
5149
diff
changeset

224 
uCursor.init(); 
2197  225 
prevPoint.X:= 0; 
74  226 
prevPoint.Y:= cScreenHeight div 2; 
8773  227 
//prevTargetPoint.X:= 0; 
228 
//prevTargetPoint.Y:= 0; 

10628  229 
WorldDx:= (LongInt(leftX + (playWidth div 2))); // (LAND_WIDTH div 2);// + cScreenWidth div 2; 
6609  230 
WorldDy:= (LAND_HEIGHT  (playHeight div 2)) + (cScreenHeight div 2); 
231 

232 
//aligns it to the bottom of the screen, minus the border 

233 
SkyOffset:= 0; 

234 
HorizontOffset:= 0; 

235 

6682  236 
InitTouchInterface(); 
6796
3e89dbdc7db9
You can now change AMAnimType to enable the animation through the x/y axis and alpha for example
Xeli
parents:
6795
diff
changeset

237 
AMAnimType:= AMTypeMaskX or AMTypeMaskAlpha; 
6682  238 
end; 
239 

240 
procedure InitCameraBorders; 

241 
begin 

242 
cGearScrEdgesDist:= min(2 * cScreenHeight div 5, 2 * cScreenWidth div 5); 

243 
end; 

244 

245 
procedure InitTouchInterface; 

246 
begin 

6676
21cf35a570a7
add keywords for landscape ammomenu and touch interface
koda
parents:
6652
diff
changeset

247 
{$IFDEF USE_TOUCH_INTERFACE} 
7167
0b3b306f129a
Android: added a callback to java to determine dpi/dip how much we should scale the ui
Xeli
parents:
7086
diff
changeset

248 

6637
b4a3310f2974
show buttons on the screen, similar to the iOS overlay
Xeli
parents:
6631
diff
changeset

249 
//positioning of the buttons 
9377  250 
buttonScale:= 1 / cDefaultZoomLevel; 
6683
75a1d84ac606
small refactoring to touch screen buttons, use a record to store values, added 'offset' fields to adjust active button area
koda
parents:
6682
diff
changeset

251 

6714
f2f93017132c
moved the firebutton, added the AMWidget button and removed the forwardjump widget(it's longpress on backjump now)
Xeli
parents:
6710
diff
changeset

252 

f2f93017132c
moved the firebutton, added the AMWidget button and removed the forwardjump widget(it's longpress on backjump now)
Xeli
parents:
6710
diff
changeset

253 
with JumpWidget do 
6695
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

254 
begin 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

255 
show:= true; 
6714
f2f93017132c
moved the firebutton, added the AMWidget button and removed the forwardjump widget(it's longpress on backjump now)
Xeli
parents:
6710
diff
changeset

256 
sprite:= sprJumpWidget; 
6695
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

257 
frame.w:= Round(spritesData[sprite].Texture^.w * buttonScale); 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

258 
frame.h:= Round(spritesData[sprite].Texture^.h * buttonScale); 
6714
f2f93017132c
moved the firebutton, added the AMWidget button and removed the forwardjump widget(it's longpress on backjump now)
Xeli
parents:
6710
diff
changeset

259 
frame.x:= (cScreenWidth shr 1)  Round(frame.w * 1.2); 
f2f93017132c
moved the firebutton, added the AMWidget button and removed the forwardjump widget(it's longpress on backjump now)
Xeli
parents:
6710
diff
changeset

260 
frame.y:= cScreenHeight  frame.h * 2; 
6710
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

261 
active.x:= frame.x; 
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

262 
active.y:= frame.y; 
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

263 
active.w:= frame.w; 
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

264 
active.h:= frame.h; 
6695
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

265 
end; 
6637
b4a3310f2974
show buttons on the screen, similar to the iOS overlay
Xeli
parents:
6631
diff
changeset

266 

6714
f2f93017132c
moved the firebutton, added the AMWidget button and removed the forwardjump widget(it's longpress on backjump now)
Xeli
parents:
6710
diff
changeset

267 
with AMWidget do 
6695
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

268 
begin 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

269 
show:= true; 
6714
f2f93017132c
moved the firebutton, added the AMWidget button and removed the forwardjump widget(it's longpress on backjump now)
Xeli
parents:
6710
diff
changeset

270 
sprite:= sprAMWidget; 
6695
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

271 
frame.w:= Round(spritesData[sprite].Texture^.w * buttonScale); 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

272 
frame.h:= Round(spritesData[sprite].Texture^.h * buttonScale); 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

273 
frame.x:= (cScreenWidth shr 1)  frame.w * 2; 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

274 
frame.y:= cScreenHeight  Round(frame.h * 1.2); 
6710
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

275 
active.x:= frame.x; 
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

276 
active.y:= frame.y; 
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

277 
active.w:= frame.w; 
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

278 
active.h:= frame.h; 
6695
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

279 
end; 
6637
b4a3310f2974
show buttons on the screen, similar to the iOS overlay
Xeli
parents:
6631
diff
changeset

280 

6688  281 
with arrowLeft do 
282 
begin 

283 
show:= true; 

284 
sprite:= sprArrowLeft; 

6695
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

285 
frame.w:= Round(spritesData[sprite].Texture^.w * buttonScale); 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

286 
frame.h:= Round(spritesData[sprite].Texture^.h * buttonScale); 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

287 
frame.x:= (cScreenWidth shr 1) + Round(frame.w * 0.25); 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

288 
frame.y:= cScreenHeight  Round(frame.h * 1.5); 
6710
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

289 
active.x:= frame.x; 
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

290 
active.y:= frame.y; 
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

291 
active.w:= frame.w; 
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

292 
active.h:= frame.h; 
6688  293 
end; 
6695
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

294 

6688  295 
with arrowRight do 
296 
begin 

297 
show:= true; 

298 
sprite:= sprArrowRight; 

6695
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

299 
frame.w:= Round(spritesData[sprite].Texture^.w * buttonScale); 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

300 
frame.h:= Round(spritesData[sprite].Texture^.h * buttonScale); 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

301 
frame.x:= (cScreenWidth shr 1) + Round(frame.w * 1.5); 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

302 
frame.y:= cScreenHeight  Round(frame.h * 1.5); 
6710
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

303 
active.x:= frame.x; 
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

304 
active.y:= frame.y; 
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

305 
active.w:= frame.w; 
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

306 
active.h:= frame.h; 
6688  307 
end; 
6637
b4a3310f2974
show buttons on the screen, similar to the iOS overlay
Xeli
parents:
6631
diff
changeset

308 

6714
f2f93017132c
moved the firebutton, added the AMWidget button and removed the forwardjump widget(it's longpress on backjump now)
Xeli
parents:
6710
diff
changeset

309 
with firebutton do 
f2f93017132c
moved the firebutton, added the AMWidget button and removed the forwardjump widget(it's longpress on backjump now)
Xeli
parents:
6710
diff
changeset

310 
begin 
f2f93017132c
moved the firebutton, added the AMWidget button and removed the forwardjump widget(it's longpress on backjump now)
Xeli
parents:
6710
diff
changeset

311 
show:= true; 
f2f93017132c
moved the firebutton, added the AMWidget button and removed the forwardjump widget(it's longpress on backjump now)
Xeli
parents:
6710
diff
changeset

312 
sprite:= sprFireButton; 
f2f93017132c
moved the firebutton, added the AMWidget button and removed the forwardjump widget(it's longpress on backjump now)
Xeli
parents:
6710
diff
changeset

313 
frame.w:= Round(spritesData[sprite].Texture^.w * buttonScale); 
f2f93017132c
moved the firebutton, added the AMWidget button and removed the forwardjump widget(it's longpress on backjump now)
Xeli
parents:
6710
diff
changeset

314 
frame.h:= Round(spritesData[sprite].Texture^.h * buttonScale); 
f2f93017132c
moved the firebutton, added the AMWidget button and removed the forwardjump widget(it's longpress on backjump now)
Xeli
parents:
6710
diff
changeset

315 
frame.x:= arrowRight.frame.x + arrowRight.frame.w; 
f2f93017132c
moved the firebutton, added the AMWidget button and removed the forwardjump widget(it's longpress on backjump now)
Xeli
parents:
6710
diff
changeset

316 
frame.y:= arrowRight.frame.y + (arrowRight.frame.w shr 1)  (frame.w shr 1); 
f2f93017132c
moved the firebutton, added the AMWidget button and removed the forwardjump widget(it's longpress on backjump now)
Xeli
parents:
6710
diff
changeset

317 
active.x:= frame.x; 
f2f93017132c
moved the firebutton, added the AMWidget button and removed the forwardjump widget(it's longpress on backjump now)
Xeli
parents:
6710
diff
changeset

318 
active.y:= frame.y; 
f2f93017132c
moved the firebutton, added the AMWidget button and removed the forwardjump widget(it's longpress on backjump now)
Xeli
parents:
6710
diff
changeset

319 
active.w:= frame.w; 
f2f93017132c
moved the firebutton, added the AMWidget button and removed the forwardjump widget(it's longpress on backjump now)
Xeli
parents:
6710
diff
changeset

320 
active.h:= frame.h; 
f2f93017132c
moved the firebutton, added the AMWidget button and removed the forwardjump widget(it's longpress on backjump now)
Xeli
parents:
6710
diff
changeset

321 
end; 
f2f93017132c
moved the firebutton, added the AMWidget button and removed the forwardjump widget(it's longpress on backjump now)
Xeli
parents:
6710
diff
changeset

322 

6688  323 
with arrowUp do 
324 
begin 

325 
show:= false; 

326 
sprite:= sprArrowUp; 

6695
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

327 
frame.w:= Round(spritesData[sprite].Texture^.w * buttonScale); 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

328 
frame.h:= Round(spritesData[sprite].Texture^.h * buttonScale); 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

329 
frame.x:= (cScreenWidth shr 1)  frame.w * 2; 
6798  330 
frame.y:= jumpWidget.frame.y  Round(frame.h * 1.25); 
6710
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

331 
active.x:= frame.x; 
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

332 
active.y:= frame.y; 
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

333 
active.w:= frame.w; 
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

334 
active.h:= frame.h; 
6688  335 
with moveAnim do 
336 
begin 

6695
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

337 
target.x:= frame.x; 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

338 
target.y:= frame.y; 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

339 
source.x:= frame.x  Round(frame.w * 0.75); 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

340 
source.y:= frame.y; 
6688  341 
end; 
342 
end; 

6637
b4a3310f2974
show buttons on the screen, similar to the iOS overlay
Xeli
parents:
6631
diff
changeset

343 

6688  344 
with arrowDown do 
345 
begin 

346 
show:= false; 

347 
sprite:= sprArrowDown; 

6695
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

348 
frame.w:= Round(spritesData[sprite].Texture^.w * buttonScale); 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

349 
frame.h:= Round(spritesData[sprite].Texture^.h * buttonScale); 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

350 
frame.x:= (cScreenWidth shr 1)  frame.w * 2; 
6798  351 
frame.y:= jumpWidget.frame.y  Round(frame.h * 1.25); 
6710
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

352 
active.x:= frame.x; 
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

353 
active.y:= frame.y; 
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

354 
active.w:= frame.w; 
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

355 
active.h:= frame.h; 
6688  356 
with moveAnim do 
357 
begin 

6695
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

358 
target.x:= frame.x; 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

359 
target.y:= frame.y; 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

360 
source.x:= frame.x + Round(frame.w * 0.75); 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

361 
source.y:= frame.y; 
6688  362 
end; 
363 
end; 

6685
ef706fccfb0a
moved other widgets under the USE_TOUCH_INTERFACE, added pause button (at least, graphically...)
koda
parents:
6683
diff
changeset

364 

6695
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

365 
with pauseButton do 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

366 
begin 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

367 
show:= true; 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

368 
sprite:= sprPauseButton; 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

369 
frame.w:= Round(spritesData[sprPauseButton].Texture^.w * buttonScale); 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

370 
frame.h:= Round(spritesData[sprPauseButton].Texture^.h * buttonScale); 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

371 
frame.x:= cScreenWidth div 2  frame.w; 
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

372 
frame.y:= 0; 
6710
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

373 
active.x:= frame.x; 
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

374 
active.y:= frame.y; 
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

375 
active.w:= frame.w; 
42504695122d
fixed the active region on widgets when they are animated, added active.x:= in uWorld too
Xeli
parents:
6706
diff
changeset

376 
active.h:= frame.h; 
6695
32de8965c62c
refactored a few types involved in the touch interface and corrected a few invisible mistakes
koda
parents:
6692
diff
changeset

377 
end; 
6685
ef706fccfb0a
moved other widgets under the USE_TOUCH_INTERFACE, added pause button (at least, graphically...)
koda
parents:
6683
diff
changeset

378 

6806
cdfb6c7099e5
first part of the utilitywidget (grenade timer/swap hogs) code
Xeli
parents:
6802
diff
changeset

379 
with utilityWidget do 
cdfb6c7099e5
first part of the utilitywidget (grenade timer/swap hogs) code
Xeli
parents:
6802
diff
changeset

380 
begin 
cdfb6c7099e5
first part of the utilitywidget (grenade timer/swap hogs) code
Xeli
parents:
6802
diff
changeset

381 
show:= false; 
cdfb6c7099e5
first part of the utilitywidget (grenade timer/swap hogs) code
Xeli
parents:
6802
diff
changeset

382 
sprite:= sprTimerButton; 
cdfb6c7099e5
first part of the utilitywidget (grenade timer/swap hogs) code
Xeli
parents:
6802
diff
changeset

383 
frame.w:= Round(spritesData[sprite].Texture^.w * buttonScale); 
cdfb6c7099e5
first part of the utilitywidget (grenade timer/swap hogs) code
Xeli
parents:
6802
diff
changeset

384 
frame.h:= Round(spritesData[sprite].Texture^.h * buttonScale); 
cdfb6c7099e5
first part of the utilitywidget (grenade timer/swap hogs) code
Xeli
parents:
6802
diff
changeset

385 
frame.x:= arrowLeft.frame.x; 
cdfb6c7099e5
first part of the utilitywidget (grenade timer/swap hogs) code
Xeli
parents:
6802
diff
changeset

386 
frame.y:= arrowLeft.frame.y  Round(frame.h * 1.25); 
cdfb6c7099e5
first part of the utilitywidget (grenade timer/swap hogs) code
Xeli
parents:
6802
diff
changeset

387 
active.x:= frame.x; 
cdfb6c7099e5
first part of the utilitywidget (grenade timer/swap hogs) code
Xeli
parents:
6802
diff
changeset

388 
active.y:= frame.y; 
cdfb6c7099e5
first part of the utilitywidget (grenade timer/swap hogs) code
Xeli
parents:
6802
diff
changeset

389 
active.w:= frame.w; 
cdfb6c7099e5
first part of the utilitywidget (grenade timer/swap hogs) code
Xeli
parents:
6802
diff
changeset

390 
active.h:= frame.h; 
cdfb6c7099e5
first part of the utilitywidget (grenade timer/swap hogs) code
Xeli
parents:
6802
diff
changeset

391 
with moveAnim do 
cdfb6c7099e5
first part of the utilitywidget (grenade timer/swap hogs) code
Xeli
parents:
6802
diff
changeset

392 
begin 
cdfb6c7099e5
first part of the utilitywidget (grenade timer/swap hogs) code
Xeli
parents:
6802
diff
changeset

393 
target.x:= frame.x; 
cdfb6c7099e5
first part of the utilitywidget (grenade timer/swap hogs) code
Xeli
parents:
6802
diff
changeset

394 
target.y:= frame.y; 
cdfb6c7099e5
first part of the utilitywidget (grenade timer/swap hogs) code
Xeli
parents:
6802
diff
changeset

395 
source.x:= frame.x; 
cdfb6c7099e5
first part of the utilitywidget (grenade timer/swap hogs) code
Xeli
parents:
6802
diff
changeset

396 
source.y:= frame.y; 
cdfb6c7099e5
first part of the utilitywidget (grenade timer/swap hogs) code
Xeli
parents:
6802
diff
changeset

397 
end; 
cdfb6c7099e5
first part of the utilitywidget (grenade timer/swap hogs) code
Xeli
parents:
6802
diff
changeset

398 
end; 
6637
b4a3310f2974
show buttons on the screen, similar to the iOS overlay
Xeli
parents:
6631
diff
changeset

399 
{$ENDIF} 
161  400 
end; 
401 

6394
f0a9042e7387
yay, finally osx (and likely windows) fullscreen switch works like on linux! ALL textures had to be destroyed and recreated only after the new window got created. In other news, the new window must be cleaned with glClear to skip a first frame of garbage and AddProgress is only called the first time.
koda
parents:
6380
diff
changeset

402 
// for uStore texture resetting 
f0a9042e7387
yay, finally osx (and likely windows) fullscreen switch works like on linux! ALL textures had to be destroyed and recreated only after the new window got created. In other news, the new window must be cleaned with glClear to skip a first frame of garbage and AddProgress is only called the first time.
koda
parents:
6380
diff
changeset

403 
procedure ResetWorldTex; 
f0a9042e7387
yay, finally osx (and likely windows) fullscreen switch works like on linux! ALL textures had to be destroyed and recreated only after the new window got created. In other news, the new window must be cleaned with glClear to skip a first frame of garbage and AddProgress is only called the first time.
koda
parents:
6380
diff
changeset

404 
begin 
10634
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10628
diff
changeset

405 
FreeAndNilTexture(fpsTexture); 
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10628
diff
changeset

406 
FreeAndNilTexture(timeTexture); 
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10628
diff
changeset

407 
FreeAndNilTexture(missionTex); 
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10628
diff
changeset

408 
FreeAndNilTexture(recTexture); 
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10628
diff
changeset

409 
FreeAndNilTexture(AmmoMenuTex); 
9983  410 
AmmoMenuInvalidated:= true; 
6394
f0a9042e7387
yay, finally osx (and likely windows) fullscreen switch works like on linux! ALL textures had to be destroyed and recreated only after the new window got created. In other news, the new window must be cleaned with glClear to skip a first frame of garbage and AddProgress is only called the first time.
koda
parents:
6380
diff
changeset

411 
end; 
f0a9042e7387
yay, finally osx (and likely windows) fullscreen switch works like on linux! ALL textures had to be destroyed and recreated only after the new window got created. In other news, the new window must be cleaned with glClear to skip a first frame of garbage and AddProgress is only called the first time.
koda
parents:
6380
diff
changeset

412 

6622  413 
function GetAmmoMenuTexture(Ammo: PHHAmmo): PTexture; 
3434  414 
const BORDERSIZE = 2; 
6622  415 
var x, y, i, t, SlotsNumY, SlotsNumX, AMFrame: LongInt; 
416 
STurns: LongInt; 

417 
amSurface: PSDL_Surface; 

418 
AMRect: TSDL_Rect; 

7049  419 
{$IFDEF USE_AM_NUMCOLUMN}tmpsurf: PSDL_Surface;{$ENDIF} 
161  420 
begin 
10141  421 
if cOnlyStats then exit(nil); 
10139  422 

6276
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

423 
SlotsNum:= 0; 
6606
fb6163ff4ebf
changed the ammomenu to be landscape for MOBILE, also tweaked the positions a bit, needs testing on iOS
Xeli
parents:
6603
diff
changeset

424 
for i:= 0 to cMaxSlotIndex do 
fb6163ff4ebf
changed the ammomenu to be landscape for MOBILE, also tweaked the positions a bit, needs testing on iOS
Xeli
parents:
6603
diff
changeset

425 
if((i = 0) and (Ammo^[i,1].Count > 0)) or ((i <> 0) and (Ammo^[i,0].Count > 0)) then 
fb6163ff4ebf
changed the ammomenu to be landscape for MOBILE, also tweaked the positions a bit, needs testing on iOS
Xeli
parents:
6603
diff
changeset

426 
inc(SlotsNum); 
6676
21cf35a570a7
add keywords for landscape ammomenu and touch interface
koda
parents:
6652
diff
changeset

427 
{$IFDEF USE_LANDSCAPE_AMMOMENU} 
6622  428 
SlotsNumX:= SlotsNum; 
429 
SlotsNumY:= cMaxSlotAmmoIndex + 2; 

6899  430 
{$IFDEF USE_AM_NUMCOLUMN} 
431 
inc(SlotsNumY); 

432 
{$ENDIF} 

6622  433 
{$ELSE} 
434 
SlotsNumX:= cMaxSlotAmmoIndex + 1; 

435 
SlotsNumY:= SlotsNum + 1; 

6899  436 
{$IFDEF USE_AM_NUMCOLUMN} 
437 
inc(SlotsNumX); 

438 
{$ENDIF} 

6622  439 
{$ENDIF} 
6606
fb6163ff4ebf
changed the ammomenu to be landscape for MOBILE, also tweaked the positions a bit, needs testing on iOS
Xeli
parents:
6603
diff
changeset

440 

6899  441 

6631  442 
AmmoRect.w:= (BORDERSIZE*2) + (SlotsNumX * AMSlotSize) + (SlotsNumX1); 
443 
AmmoRect.h:= (BORDERSIZE*2) + (SlotsNumY * AMSlotSize) + (SlotsNumY1); 

444 
amSurface := SDL_CreateRGBSurface(SDL_SWSURFACE, AmmoRect.w, AmmoRect.h, 32, RMask, GMask, BMask, AMask); 

8330  445 

6622  446 
AMRect.x:= BORDERSIZE; 
447 
AMRect.y:= BORDERSIZE; 

6631  448 
AMRect.w:= AmmoRect.w  (BORDERSIZE*2); 
449 
AMRect.h:= AmmoRect.h  (BORDERSIZE*2); 

6276
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

450 

6622  451 
SDL_FillRect(amSurface, @AMRect, SDL_MapRGB(amSurface^.format, 0,0,0)); 
8330  452 

6650
56a0b7bf6c15
fixed the blackpixel in the ammomenu, x,y in GetAmmoMenuTexture now initialized correctly
Xeli
parents:
6648
diff
changeset

453 
x:= AMRect.x; 
56a0b7bf6c15
fixed the blackpixel in the ammomenu, x,y in GetAmmoMenuTexture now initialized correctly
Xeli
parents:
6648
diff
changeset

454 
y:= AMRect.y; 
6276
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

455 
for i:= 0 to cMaxSlotIndex do 
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

456 
if ((i = 0) and (Ammo^[i, 1].Count > 0)) or ((i <> 0) and (Ammo^[i, 0].Count > 0)) then 
3434  457 
begin 
6676
21cf35a570a7
add keywords for landscape ammomenu and touch interface
koda
parents:
6652
diff
changeset

458 
{$IFDEF USE_LANDSCAPE_AMMOMENU} 
6650
56a0b7bf6c15
fixed the blackpixel in the ammomenu, x,y in GetAmmoMenuTexture now initialized correctly
Xeli
parents:
6648
diff
changeset

459 
y:= AMRect.y; 
6622  460 
{$ELSE} 
6650
56a0b7bf6c15
fixed the blackpixel in the ammomenu, x,y in GetAmmoMenuTexture now initialized correctly
Xeli
parents:
6648
diff
changeset

461 
x:= AMRect.x; 
6622  462 
{$ENDIF} 
6899  463 
{$IFDEF USE_AM_NUMCOLUMN} 
6918  464 
tmpsurf:= TTF_RenderUTF8_Blended(Fontz[fnt16].Handle, Str2PChar('F' + IntToStr(i+1)), cWhiteColorChannels); 
6899  465 
copyToXY(tmpsurf, amSurface, 
466 
x + AMSlotPadding + (AMSlotSize shr 1)  (tmpsurf^.w shr 1), 

467 
y + AMSlotPadding + (AMSlotSize shr 1)  (tmpsurf^.h shr 1)); 

468 

469 
SDL_FreeSurface(tmpsurf); 

470 
{$IFDEF USE_LANDSCAPE_AMMOMENU} 

471 
y:= AMRect.y + AMSlotSize + 1; 

472 
{$ELSE} 

473 
x:= AMRect.x + AMSlotSize + 1; 

474 
{$ENDIF} 

475 
{$ENDIF} 

476 

477 

6606
fb6163ff4ebf
changed the ammomenu to be landscape for MOBILE, also tweaked the positions a bit, needs testing on iOS
Xeli
parents:
6603
diff
changeset

478 
for t:=0 to cMaxSlotAmmoIndex do 
3434  479 
begin 
6622  480 
if (Ammo^[i, t].Count > 0) and (Ammo^[i, t].AmmoType <> amNothing) then 
3434  481 
begin 
6622  482 
STurns:= Ammoz[Ammo^[i, t].AmmoType].SkipTurns  CurrentTeam^.Clan^.TurnNumber; 
483 
AMFrame:= LongInt(Ammo^[i,t].AmmoType)  1; 

484 
if STurns >= 0 then //weapon not usable yet, draw grayed out with turns remaining 

6276
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

485 
begin 
8330  486 
DrawSpriteFrame2Surf(sprAMAmmosBW, amSurface, x + AMSlotPadding, 
6650
56a0b7bf6c15
fixed the blackpixel in the ammomenu, x,y in GetAmmoMenuTexture now initialized correctly
Xeli
parents:
6648
diff
changeset

487 
y + AMSlotPadding, AMFrame); 
6622  488 
if STurns < 100 then 
8330  489 
DrawSpriteFrame2Surf(sprTurnsLeft, amSurface, 
490 
x + AMSlotSize16, 

7013  491 
y + AMSlotSize + 1  16, STurns); 
6622  492 
end 
493 
else //draw colored version 

494 
begin 

8330  495 
DrawSpriteFrame2Surf(sprAMAmmos, amSurface, x + AMSlotPadding, 
6899  496 
y + AMSlotPadding, AMFrame); 
6276
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

497 
end; 
6676
21cf35a570a7
add keywords for landscape ammomenu and touch interface
koda
parents:
6652
diff
changeset

498 
{$IFDEF USE_LANDSCAPE_AMMOMENU} 
8330  499 
inc(y, AMSlotSize + 1); //the plus one is for the border 
6622  500 
{$ELSE} 
8330  501 
inc(x, AMSlotSize + 1); 
6622  502 
{$ENDIF} 
8330  503 
end; 
504 
end; 

6676
21cf35a570a7
add keywords for landscape ammomenu and touch interface
koda
parents:
6652
diff
changeset

505 
{$IFDEF USE_LANDSCAPE_AMMOMENU} 
6622  506 
inc(x, AMSlotSize + 1); 
6276
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

507 
{$ELSE} 
6622  508 
inc(y, AMSlotSize + 1); 
509 
{$ENDIF} 

510 
end; 

511 

512 
for i:= 1 to SlotsNumX 1 do 

8330  513 
DrawLine2Surf(amSurface, i * (AMSlotSize+1)+1, BORDERSIZE, i * (AMSlotSize+1)+1, AMRect.h + BORDERSIZE  AMSlotSize  2,160,160,160); 
6622  514 
for i:= 1 to SlotsNumY 1 do 
6652  515 
DrawLine2Surf(amSurface, BORDERSIZE, i * (AMSlotSize+1)+1, AMRect.w + BORDERSIZE, i * (AMSlotSize+1)+1,160,160,160); 
6622  516 

517 
//draw outer border 

7013  518 
DrawSpriteFrame2Surf(sprAMCorners, amSurface, 0 , 0 , 0); 
519 
DrawSpriteFrame2Surf(sprAMCorners, amSurface, AMRect.w + BORDERSIZE, AMRect.y , 1); 

520 
DrawSpriteFrame2Surf(sprAMCorners, amSurface, AMRect.x , AMRect.h + BORDERSIZE, 2); 

521 
DrawSpriteFrame2Surf(sprAMCorners, amSurface, AMRect.w + BORDERSIZE, AMRect.h + BORDERSIZE, 3); 

6622  522 

523 
for i:=0 to BORDERSIZE1 do 

524 
begin 

525 
DrawLine2Surf(amSurface, BORDERSIZE, i, AMRect.w + BORDERSIZE, i,160,160,160);//top 

526 
DrawLine2Surf(amSurface, BORDERSIZE, AMRect.h+BORDERSIZE+i, AMRect.w + BORDERSIZE, AMRect.h+BORDERSIZE+i,160,160,160);//bottom 

527 
DrawLine2Surf(amSurface, i, BORDERSIZE, i, AMRect.h + BORDERSIZE,160,160,160);//left 

528 
DrawLine2Surf(amSurface, AMRect.w+BORDERSIZE+i, BORDERSIZE, AMRect.w + BORDERSIZE+i, AMRect.h + BORDERSIZE, 160,160,160);//right 

529 
end; 

530 

531 
GetAmmoMenuTexture:= Surface2Tex(amSurface, false); 

532 
if amSurface <> nil then SDL_FreeSurface(amSurface); 

533 
end; 

534 

535 
procedure ShowAmmoMenu; 

536 
const BORDERSIZE = 2; 

537 
var Slot, Pos: LongInt; 

538 
Ammo: PHHAmmo; 

6648
025473a2c420
prevent the cursor from being shown on the mobile version, and close the menu on tap when the tap is not on the ammo menu
Xeli
parents:
6647
diff
changeset

539 
c,i,g,t,STurns: LongInt; 
6622  540 
begin 
7946
a99a79bbd857
Simplify ammo menu conditions so it shows up in more states. Should fix issue #465. The part w/ sliding in uworld is main #465 problem.
nemo
parents:
7858
diff
changeset

541 
if TurnTimeLeft = 0 then bShowAmmoMenu:= false; 
6622  542 

543 
// give the assigned ammo to hedgehog 

544 
Ammo:= nil; 

545 
if (CurrentTeam <> nil) and (CurrentHedgehog <> nil) 

546 
and (not CurrentTeam^.ExtDriven) and (CurrentHedgehog^.BotLevel = 0) then 

6918  547 
Ammo:= CurrentHedgehog^.Ammo 
6622  548 
else if (LocalAmmo <> 1) then 
6918  549 
Ammo:= GetAmmoByNum(LocalAmmo); 
6622  550 
Pos:= 1; 
551 
if Ammo = nil then 

6918  552 
begin 
553 
bShowAmmoMenu:= false; 

554 
AMState:= AMHidden; 

555 
exit 

556 
end; 

6622  557 

8330  558 
//Init the menu 
559 
if(AmmoMenuInvalidated) then 

6622  560 
begin 
561 
AmmoMenuInvalidated:= false; 

10634
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10628
diff
changeset

562 
FreeAndNilTexture(AmmoMenuTex); 
6622  563 
AmmoMenuTex:= GetAmmoMenuTexture(Ammo); 
3697  564 

6676
21cf35a570a7
add keywords for landscape ammomenu and touch interface
koda
parents:
6652
diff
changeset

565 
{$IFDEF USE_LANDSCAPE_AMMOMENU} 
6622  566 
if isPhone() then 
567 
begin 

568 
AmmoRect.x:= (AmmoRect.w shr 1); 

569 
AmmoRect.y:= (cScreenHeight shr 1)  (AmmoRect.h shr 1); 

570 
end 

571 
else 

572 
begin 

573 
AmmoRect.x:= (AmmoRect.w shr 1); 

574 
AmmoRect.y:= cScreenHeight  (AmmoRect.h + AMSlotSize); 

575 
end; 

576 
{$ELSE} 

577 
AmmoRect.x:= (cScreenWidth shr 1)  AmmoRect.w  AMSlotSize; 

578 
AmmoRect.y:= cScreenHeight  (AmmoRect.h + AMSlotSize); 

579 
{$ENDIF} 

7946
a99a79bbd857
Simplify ammo menu conditions so it shows up in more states. Should fix issue #465. The part w/ sliding in uworld is main #465 problem.
nemo
parents:
7858
diff
changeset

580 
if AMState <> AMShowing then 
a99a79bbd857
Simplify ammo menu conditions so it shows up in more states. Should fix issue #465. The part w/ sliding in uworld is main #465 problem.
nemo
parents:
7858
diff
changeset

581 
begin 
a99a79bbd857
Simplify ammo menu conditions so it shows up in more states. Should fix issue #465. The part w/ sliding in uworld is main #465 problem.
nemo
parents:
7858
diff
changeset

582 
AMShiftTargetX:= (cScreenWidth shr 1)  AmmoRect.x; 
a99a79bbd857
Simplify ammo menu conditions so it shows up in more states. Should fix issue #465. The part w/ sliding in uworld is main #465 problem.
nemo
parents:
7858
diff
changeset

583 
AMShiftTargetY:= cScreenHeight  AmmoRect.y; 
6802  584 

7946
a99a79bbd857
Simplify ammo menu conditions so it shows up in more states. Should fix issue #465. The part w/ sliding in uworld is main #465 problem.
nemo
parents:
7858
diff
changeset

585 
if (AMAnimType and AMTypeMaskX) <> 0 then AMShiftTargetX:= (cScreenWidth shr 1)  AmmoRect.x 
a99a79bbd857
Simplify ammo menu conditions so it shows up in more states. Should fix issue #465. The part w/ sliding in uworld is main #465 problem.
nemo
parents:
7858
diff
changeset

586 
else AMShiftTargetX:= 0; 
a99a79bbd857
Simplify ammo menu conditions so it shows up in more states. Should fix issue #465. The part w/ sliding in uworld is main #465 problem.
nemo
parents:
7858
diff
changeset

587 
if (AMAnimType and AMTypeMaskY) <> 0 then AMShiftTargetY:= cScreenHeight  AmmoRect.y 
a99a79bbd857
Simplify ammo menu conditions so it shows up in more states. Should fix issue #465. The part w/ sliding in uworld is main #465 problem.
nemo
parents:
7858
diff
changeset

588 
else AMShiftTargetY:= 0; 
6802  589 

7946
a99a79bbd857
Simplify ammo menu conditions so it shows up in more states. Should fix issue #465. The part w/ sliding in uworld is main #465 problem.
nemo
parents:
7858
diff
changeset

590 
AMShiftX:= AMShiftTargetX; 
a99a79bbd857
Simplify ammo menu conditions so it shows up in more states. Should fix issue #465. The part w/ sliding in uworld is main #465 problem.
nemo
parents:
7858
diff
changeset

591 
AMShiftY:= AMShiftTargetY 
a99a79bbd857
Simplify ammo menu conditions so it shows up in more states. Should fix issue #465. The part w/ sliding in uworld is main #465 problem.
nemo
parents:
7858
diff
changeset

592 
end 
6622  593 
end; 
594 

6795
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

595 
AMAnimState:= (RealTicks  AMAnimStartTime) / AMAnimDuration; 
6802  596 

597 
if AMState = AMShowing then 

598 
begin 

599 
FollowGear:=nil; 

600 
end; 

601 

6795
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

602 
if AMState = AMShowingUp then // show ammo menu 
6622  603 
begin 
604 
if (cReducedQuality and rqSlowMenu) <> 0 then 

605 
begin 

606 
AMShiftX:= 0; 

607 
AMShiftY:= 0; 

6795
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

608 
AMState:= AMShowing; 
6622  609 
end 
610 
else 

6795
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

611 
if AMAnimState < 1 then 
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

612 
begin 
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

613 
AMShiftX:= Round(AMShiftTargetX * (1  AMAnimState)); 
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

614 
AMShiftY:= Round(AMShiftTargetY * (1  AMAnimState)); 
8330  615 
if (AMAnimType and AMTypeMaskAlpha) <> 0 then 
6796
3e89dbdc7db9
You can now change AMAnimType to enable the animation through the x/y axis and alpha for example
Xeli
parents:
6795
diff
changeset

616 
Tint($FF, $ff, $ff, Round($ff * AMAnimState)); 
6795
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

617 
end 
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

618 
else 
6622  619 
begin 
6795
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

620 
AMShiftX:= 0; 
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

621 
AMShiftY:= 0; 
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

622 
CursorPoint.X:= AmmoRect.x + AmmoRect.w; 
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

623 
CursorPoint.Y:= AmmoRect.y; 
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

624 
AMState:= AMShowing; 
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

625 
end; 
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

626 
end; 
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

627 
if AMState = AMHiding then // hide ammo menu 
6622  628 
begin 
629 
if (cReducedQuality and rqSlowMenu) <> 0 then 

630 
begin 

631 
AMShiftX:= AMShiftTargetX; 

632 
AMShiftY:= AMShiftTargetY; 

6795
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

633 
AMState:= AMHidden; 
6622  634 
end 
635 
else 

6795
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

636 
if AMAnimState < 1 then 
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

637 
begin 
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

638 
AMShiftX:= Round(AMShiftTargetX * AMAnimState); 
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

639 
AMShiftY:= Round(AMShiftTargetY * AMAnimState); 
8330  640 
if (AMAnimType and AMTypeMaskAlpha) <> 0 then 
6796
3e89dbdc7db9
You can now change AMAnimType to enable the animation through the x/y axis and alpha for example
Xeli
parents:
6795
diff
changeset

641 
Tint($FF, $ff, $ff, Round($ff * (1AMAnimState))); 
6795
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

642 
end 
8330  643 
else 
6622  644 
begin 
6795
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

645 
AMShiftX:= AMShiftTargetX; 
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

646 
AMShiftY:= AMShiftTargetY; 
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

647 
prevPoint:= CursorPoint; 
8773  648 
//prevTargetPoint:= TargetCursorPoint; 
6795
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

649 
AMState:= AMHidden; 
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

650 
end; 
6622  651 
end; 
8330  652 

6795
e4831e13e04a
make ammomenu's speed dependent on RealTicks rather than frames
Xeli
parents:
6794
diff
changeset

653 
DrawTexture(AmmoRect.x + AMShiftX, AmmoRect.y + AMShiftY, AmmoMenuTex); 
6796
3e89dbdc7db9
You can now change AMAnimType to enable the animation through the x/y axis and alpha for example
Xeli
parents:
6795
diff
changeset

654 

8330  655 
if ((AMState = AMHiding) or (AMState = AMShowingUp)) and ((AMAnimType and AMTypeMaskAlpha) <> 0 )then 
10032
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
10009
diff
changeset

656 
untint; 
6622  657 

6796
3e89dbdc7db9
You can now change AMAnimType to enable the animation through the x/y axis and alpha for example
Xeli
parents:
6795
diff
changeset

658 
Pos:= 1; 
3e89dbdc7db9
You can now change AMAnimType to enable the animation through the x/y axis and alpha for example
Xeli
parents:
6795
diff
changeset

659 
Slot:= 1; 
6899  660 
{$IFDEF USE_LANDSCAPE_AMMOMENU} 
6796
3e89dbdc7db9
You can now change AMAnimType to enable the animation through the x/y axis and alpha for example
Xeli
parents:
6795
diff
changeset

661 
c:= 1; 
6622  662 
for i:= 0 to cMaxSlotIndex do 
6276
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

663 
if ((i = 0) and (Ammo^[i, 1].Count > 0)) or ((i <> 0) and (Ammo^[i, 0].Count > 0)) then 
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

664 
begin 
6631  665 
inc(c); 
6918  666 
{$IFDEF USE_AM_NUMCOLUMN} 
6899  667 
g:= 1; 
6918  668 
{$ELSE} 
6622  669 
g:= 0; 
6918  670 
{$ENDIF} 
6622  671 
for t:=0 to cMaxSlotAmmoIndex do 
672 
if (Ammo^[i, t].Count > 0) and (Ammo^[i, t].AmmoType <> amNothing) then 

6276
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

673 
begin 
6622  674 
if (CursorPoint.Y <= (cScreenHeight  AmmoRect.y)  ( g * (AMSlotSize+1))) and 
7841
43e68ac28d79
apply unC0Rr's fix for 435 to landscape and non numbered ammomenu
Xeli
parents:
7840
diff
changeset

675 
(CursorPoint.Y > (cScreenHeight  AmmoRect.y)  ((g+1) * (AMSlotSize+1))) and 
8330  676 
(CursorPoint.X > AmmoRect.x + ( c * (AMSlotSize+1))) and 
6631  677 
(CursorPoint.X <= AmmoRect.x + ((c+1) * (AMSlotSize+1))) then 
6276
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

678 
begin 
6622  679 
Slot:= i; 
6276
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

680 
Pos:= t; 
6622  681 
STurns:= Ammoz[Ammo^[i, t].AmmoType].SkipTurns  CurrentTeam^.Clan^.TurnNumber; 
682 
if (STurns < 0) and (AMShiftX = 0) and (AMShiftY = 0) then 

8330  683 
DrawSprite(sprAMSlot, 
684 
AmmoRect.x + BORDERSIZE + (c * (AMSlotSize+1)) + AMSlotPadding, 

6622  685 
AmmoRect.y + BORDERSIZE + (g * (AMSlotSize+1)) + AMSlotPadding 1, 0); 
6276
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

686 
end; 
6622  687 
inc(g); 
688 
end; 

6276
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

689 
end; 
6622  690 
{$ELSE} 
6918  691 
c:= 1; 
6622  692 
for i:= 0 to cMaxSlotIndex do 
693 
if ((i = 0) and (Ammo^[i, 1].Count > 0)) or ((i <> 0) and (Ammo^[i, 0].Count > 0)) then 

694 
begin 

6631  695 
inc(c); 
6918  696 
{$IFDEF USE_AM_NUMCOLUMN} 
6899  697 
g:= 1; 
6918  698 
{$ELSE} 
6622  699 
g:= 0; 
6918  700 
{$ENDIF} 
6622  701 
for t:=0 to cMaxSlotAmmoIndex do 
702 
if (Ammo^[i, t].Count > 0) and (Ammo^[i, t].AmmoType <> amNothing) then 

703 
begin 

6631  704 
if (CursorPoint.Y <= (cScreenHeight  AmmoRect.y)  ( c * (AMSlotSize+1))) and 
7840
7d86dbcd6325
Fix issue 435, and also unreported bug when 2 or even 4 entries could have selection at the same time in weapons menu.
unc0rr
parents:
7721
diff
changeset

705 
(CursorPoint.Y > (cScreenHeight  AmmoRect.y)  ((c+1) * (AMSlotSize+1))) and 
8330  706 
(CursorPoint.X > AmmoRect.x + ( g * (AMSlotSize+1))) and 
6622  707 
(CursorPoint.X <= AmmoRect.x + ((g+1) * (AMSlotSize+1))) then 
708 
begin 

709 
Slot:= i; 

710 
Pos:= t; 

711 
STurns:= Ammoz[Ammo^[i, t].AmmoType].SkipTurns  CurrentTeam^.Clan^.TurnNumber; 

712 
if (STurns < 0) and (AMShiftX = 0) and (AMShiftY = 0) then 

8330  713 
DrawSprite(sprAMSlot, 
714 
AmmoRect.x + BORDERSIZE + (g * (AMSlotSize+1)) + AMSlotPadding, 

6631  715 
AmmoRect.y + BORDERSIZE + (c * (AMSlotSize+1)) + AMSlotPadding 1, 0); 
6622  716 
end; 
717 
inc(g); 

718 
end; 

719 
end; 

3395
095273ad0e08
adding a somewhat working autoration for ipad (uStore.pas and uWorld.pas got mixed in the last two commits)
koda
parents:
3390
diff
changeset

720 
{$ENDIF} 
6622  721 
if (Pos >= 0) and (Pos <= cMaxSlotAmmoIndex) and (Slot >= 0) and (Slot <= cMaxSlotIndex)then 
3967  722 
begin 
6622  723 
if (AMShiftX = 0) and (AMShiftY = 0) then 
6276
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

724 
if (Ammo^[Slot, Pos].Count > 0) and (Ammo^[Slot, Pos].AmmoType <> amNothing) then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2931
diff
changeset

725 
begin 
6276
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

726 
if (amSel <> Ammo^[Slot, Pos].AmmoType) or (WeaponTooltipTex = nil) then 
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

727 
begin 
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

728 
amSel:= Ammo^[Slot, Pos].AmmoType; 
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

729 
RenderWeaponTooltip(amSel) 
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

730 
end; 
3697  731 

6622  732 
DrawTexture(AmmoRect.x + (AMSlotSize shr 1), 
733 
AmmoRect.y + AmmoRect.h  BORDERSIZE  (AMSlotSize shr 1)  (Ammoz[Ammo^[Slot, Pos].AmmoType].NameTex^.h shr 1), 

6608  734 
Ammoz[Ammo^[Slot, Pos].AmmoType].NameTex); 
6276
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

735 
if Ammo^[Slot, Pos].Count < AMMO_INFINITE then 
6622  736 
DrawTexture(AmmoRect.x + AmmoRect.w  20  (CountTexz[Ammo^[Slot, Pos].Count]^.w), 
737 
AmmoRect.y + AmmoRect.h  BORDERSIZE  (AMslotSize shr 1)  (CountTexz[Ammo^[Slot, Pos].Count]^.w shr 1), 

6608  738 
CountTexz[Ammo^[Slot, Pos].Count]); 
1529
3bc916b419cd
Don't hide ammo menu when user clicks on not yet available weapon
unc0rr
parents:
1439
diff
changeset

739 

6276
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

740 
if bSelected and (Ammoz[Ammo^[Slot, Pos].AmmoType].SkipTurns  CurrentTeam^.Clan^.TurnNumber < 0) then 
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

741 
begin 
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

742 
bShowAmmoMenu:= false; 
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

743 
SetWeapon(Ammo^[Slot, Pos].AmmoType); 
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

744 
bSelected:= false; 
10634
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10628
diff
changeset

745 
FreeAndNilTexture(WeaponTooltipTex); 
6691
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6688
diff
changeset

746 
{$IFDEF USE_TOUCH_INTERFACE}//show the aiming buttons + animation 
6941
228c0ab239f1
add ammoprop to enable to up and down buttons on for the touch interface
Xeli
parents:
6924
diff
changeset

747 
if (Ammo^[Slot, Pos].Propz and ammoprop_NeedUpDown) <> 0 then 
6691
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6688
diff
changeset

748 
begin 
8099
a7f02b902b6f
throw in some 'nots' trying to restore pas2c functionality
koda
parents:
8026
diff
changeset

749 
if (not arrowUp.show) then 
6691
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6688
diff
changeset

750 
begin 
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6688
diff
changeset

751 
animateWidget(@arrowUp, true, true); 
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6688
diff
changeset

752 
animateWidget(@arrowDown, true, true); 
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6688
diff
changeset

753 
end; 
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6688
diff
changeset

754 
end 
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6688
diff
changeset

755 
else 
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6688
diff
changeset

756 
if arrowUp.show then 
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6688
diff
changeset

757 
begin 
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6688
diff
changeset

758 
animateWidget(@arrowUp, true, false); 
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6688
diff
changeset

759 
animateWidget(@arrowDown, true, false); 
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6688
diff
changeset

760 
end; 
6961
d5ac09894a1b
hide utilitywidget when changing turns, this also fixes some inconsistency when using targetting weapons
Xeli
parents:
6957
diff
changeset

761 
SetUtilityWidgetState(Ammo^[Slot, Pos].AmmoType); 
6691
79c96abd06d6
added hide/show animation for the aiming keys (should animateWidget() be moved to another unit?)
Xeli
parents:
6688
diff
changeset

762 
{$ENDIF} 
6276
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

763 
exit 
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

764 
end; 
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

765 
end 
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

766 
end 
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

767 
else 
10634
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10628
diff
changeset

768 
FreeAndNilTexture(WeaponTooltipTex); 
6276
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

769 

6622  770 
if (WeaponTooltipTex <> nil) and (AMShiftX = 0) and (AMShiftY = 0) then 
6676
21cf35a570a7
add keywords for landscape ammomenu and touch interface
koda
parents:
6652
diff
changeset

771 
{$IFDEF USE_LANDSCAPE_AMMOMENU} 
8099
a7f02b902b6f
throw in some 'nots' trying to restore pas2c functionality
koda
parents:
8026
diff
changeset

772 
if (not isPhone()) then 
6622  773 
ShowWeaponTooltip(WeaponTooltipTex^.w div 2, AmmoRect.y  WeaponTooltipTex^.h  AMSlotSize); 
3395
095273ad0e08
adding a somewhat working autoration for ipad (uStore.pas and uWorld.pas got mixed in the last two commits)
koda
parents:
3390
diff
changeset

774 
{$ELSE} 
6622  775 
ShowWeaponTooltip(AmmoRect.x  WeaponTooltipTex^.w  3, Min(AmmoRect.y + 1, cScreenHeight  WeaponTooltipTex^.h  40)); 
3395
095273ad0e08
adding a somewhat working autoration for ipad (uStore.pas and uWorld.pas got mixed in the last two commits)
koda
parents:
3390
diff
changeset

776 
{$ENDIF} 
961
a9a349b2b3fa
Use turnsleft sprites to indicate turns left to activate ammo
unc0rr
parents:
956
diff
changeset

777 

6276
1e2f8da1860a
while formatting the ammomenu code i found out that it's simpler to move than i thought, and fixed a small glitch when animation was disabled
koda
parents:
6250
diff
changeset

778 
bSelected:= false; 
6899  779 
{$IFNDEF USE_TOUCH_INTERFACE} 
6648
025473a2c420
prevent the cursor from being shown on the mobile version, and close the menu on tap when the tap is not on the ammo menu
Xeli
parents:
6647
diff
changeset

780 
if (AMShiftX = 0) and (AMShiftY = 0) then 
6622  781 
DrawSprite(sprArrow, CursorPoint.X, cScreenHeight  CursorPoint.Y, (RealTicks shr 6) mod 8); 
6648
025473a2c420
prevent the cursor from being shown on the mobile version, and close the menu on tap when the tap is not on the ammo menu
Xeli
parents:
6647
diff
changeset

782 
{$ENDIF} 
4  783 
end; 
784 

3089  785 
procedure DrawRepeated(spr, sprL, sprR: TSprite; Shift, OffsetY: LongInt); 
3537
8f5b3108f29c
New approach to the lowres problem. Basically, we already have a 1024 minimum, and the tallest maps are restricting themselves to 2048 maximum. All backgrounds are scaled down 50%, then scaled up on draw. Saves memory, and backgrounds are already deliberately fuzzed for depth of field anyway.
nemo
parents:
3523
diff
changeset

786 
var i, w, h, lw, lh, rw, rh, sw: LongInt; 
2426  787 
begin 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

788 
sw:= round(cScreenWidth / cScaleFactor); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

789 
if (SpritesData[sprL].Texture = nil) and (SpritesData[spr].Texture <> nil) then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

790 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

791 
w:= SpritesData[spr].Width * SpritesData[spr].Texture^.Scale; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

792 
h:= SpritesData[spr].Height * SpritesData[spr].Texture^.Scale; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

793 
i:= Shift mod w; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

794 
if i > 0 then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

795 
dec(i, w); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

796 
dec(i, w * (sw div w + 1)); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

797 
repeat 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

798 
DrawTexture(i, WorldDy + LAND_HEIGHT + OffsetY  h, SpritesData[spr].Texture, SpritesData[spr].Texture^.Scale); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

799 
inc(i, w) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

800 
until i > sw 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

801 
end 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

802 
else if SpritesData[spr].Texture <> nil then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

803 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

804 
w:= SpritesData[spr].Width * SpritesData[spr].Texture^.Scale; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

805 
h:= SpritesData[spr].Height * SpritesData[spr].Texture^.Scale; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

806 
lw:= SpritesData[sprL].Width * SpritesData[spr].Texture^.Scale; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

807 
lh:= SpritesData[sprL].Height * SpritesData[spr].Texture^.Scale; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

808 
if SpritesData[sprR].Texture <> nil then 
5285
af4dc03dd60d
Make sky, horizon, flakes and clouds optional, replace repeated strips of skyL/skyR with 2x2 transparent PNGs instead of larger images of variable dimensions, remove a number of empty unused images
nemo
parents:
5191
diff
changeset

809 
begin 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

810 
rw:= SpritesData[sprR].Width * SpritesData[spr].Texture^.Scale; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

811 
rh:= SpritesData[sprR].Height * SpritesData[spr].Texture^.Scale 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

812 
end; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

813 
dec(Shift, w div 2); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

814 
DrawTexture(Shift, WorldDy + LAND_HEIGHT + OffsetY  h, SpritesData[spr].Texture, SpritesData[spr].Texture^.Scale); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

815 

6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

816 
i:= Shift  lw; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

817 
while i >= sw  lw do 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

818 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

819 
DrawTexture(i, WorldDy + LAND_HEIGHT + OffsetY  lh, SpritesData[sprL].Texture, SpritesData[sprL].Texture^.Scale); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

820 
dec(i, lw); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

821 
end; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

822 

6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

823 
i:= Shift + w; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

824 
if SpritesData[sprR].Texture <> nil then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

825 
while i <= sw do 
6135
2172330ad52a
Use SkyL if SkyR is not included. Saves a bit of texture memory and removes some redundant files.
nemo
parents:
6131
diff
changeset

826 
begin 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

827 
DrawTexture(i, WorldDy + LAND_HEIGHT + OffsetY  rh, SpritesData[sprR].Texture, SpritesData[sprR].Texture^.Scale); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

828 
inc(i, rw) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

829 
end 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

830 
else 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

831 
while i <= sw do 
5285
af4dc03dd60d
Make sky, horizon, flakes and clouds optional, replace repeated strips of skyL/skyR with 2x2 transparent PNGs instead of larger images of variable dimensions, remove a number of empty unused images
nemo
parents:
5191
diff
changeset

832 
begin 
3537
8f5b3108f29c
New approach to the lowres problem. Basically, we already have a 1024 minimum, and the tallest maps are restricting themselves to 2048 maximum. All backgrounds are scaled down 50%, then scaled up on draw. Saves memory, and backgrounds are already deliberately fuzzed for depth of field anyway.
nemo
parents:
3523
diff
changeset

833 
DrawTexture(i, WorldDy + LAND_HEIGHT + OffsetY  lh, SpritesData[sprL].Texture, SpritesData[sprL].Texture^.Scale); 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

834 
inc(i, lw) 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

835 
end 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

836 
end 
2426  837 
end; 
838 

839 

956  840 
procedure DrawWorld(Lag: LongInt); 
4  841 
begin 
6734
9709d15dabfa
Revert most of 033e4a8a9c74 and 9d501dc22f71 (see bug #362)
nemo
parents:
6714
diff
changeset

842 
if ZoomValue < zoom then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2931
diff
changeset

843 
begin 
6734
9709d15dabfa
Revert most of 033e4a8a9c74 and 9d501dc22f71 (see bug #362)
nemo
parents:
6714
diff
changeset

844 
zoom:= zoom  0.002 * Lag; 
9709d15dabfa
Revert most of 033e4a8a9c74 and 9d501dc22f71 (see bug #362)
nemo
parents:
6714
diff
changeset

845 
if ZoomValue > zoom then 
9709d15dabfa
Revert most of 033e4a8a9c74 and 9d501dc22f71 (see bug #362)
nemo
parents:
6714
diff
changeset

846 
zoom:= ZoomValue 
9709d15dabfa
Revert most of 033e4a8a9c74 and 9d501dc22f71 (see bug #362)
nemo
parents:
6714
diff
changeset

847 
end 
9709d15dabfa
Revert most of 033e4a8a9c74 and 9d501dc22f71 (see bug #362)
nemo
parents:
6714
diff
changeset

848 
else 
9709d15dabfa
Revert most of 033e4a8a9c74 and 9d501dc22f71 (see bug #362)
nemo
parents:
6714
diff
changeset

849 
if ZoomValue > zoom then 
3444  850 
begin 
6734
9709d15dabfa
Revert most of 033e4a8a9c74 and 9d501dc22f71 (see bug #362)
nemo
parents:
6714
diff
changeset

851 
zoom:= zoom + 0.002 * Lag; 
9709d15dabfa
Revert most of 033e4a8a9c74 and 9d501dc22f71 (see bug #362)
nemo
parents:
6714
diff
changeset

852 
if ZoomValue < zoom then 
9709d15dabfa
Revert most of 033e4a8a9c74 and 9d501dc22f71 (see bug #362)
nemo
parents:
6714
diff
changeset

853 
zoom:= ZoomValue 
3444  854 
end 
3611  855 
else 
856 
ZoomValue:= zoom; 

2376  857 

9670
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9666
diff
changeset

858 
if (not isPaused) and (not isAFK) and (GameType <> gmtRecord) then 
3594
aeca3d8f1b29
turn cReducedQuality into a LongInt and provide a series of quality flags (and best of all, this is still compatible with current frontend)
koda
parents:
3582
diff
changeset

859 
MoveCamera; 
162  860 

3696  861 
if cStereoMode = smNone then 
862 
begin 

10869  863 
RenderClear(); 
3692  864 
DrawWorldStereo(Lag, rmDefault) 
11000  865 
{$IFDEF USE_S3D_RENDERING} 
3696  866 
end 
10869  867 
else 
3696  868 
begin 
10869  869 
// draw frame for left eye 
870 
RenderClear(rmLeftEye); 

3692  871 
DrawWorldStereo(Lag, rmLeftEye); 
872 

10869  873 
// draw frame for right eye 
874 
RenderClear(rmRightEye); 

3692  875 
DrawWorldStereo(0, rmRightEye); 
11000  876 
{$ENDIF} 
10869  877 
end; 
3692  878 

10869  879 
FinishRender(); 
3692  880 
end; 
881 

10494  882 
procedure RenderWorldEdge; 
9654  883 
var 
10360
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

884 
//VertexBuffer: array [0..3] of TVertex2f; 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

885 
tmp, w: LongInt; 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

886 
rect: TSDL_Rect; 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

887 
//c1, c2: LongWord; // couple of colours for edges 
9654  888 
begin 
10318  889 
if (WorldEdge <> weNone) and (WorldEdge <> weSea) then 
9654  890 
begin 
891 
(* I think for a bounded world, will fill the left and right areas with black or something. Also will probably want various border effects/animations based on border type. Prob also, say, trigger a border animation timer on an impact. *) 

892 

10360
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

893 
rect.y:= ViewTopY; 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

894 
rect.h:= ViewHeight; 
10494  895 
tmp:= LongInt(leftX) + WorldDx; 
10360
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

896 
w:= tmp  ViewLeftX; 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

897 

c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

898 
if w > 0 then 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

899 
begin 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

900 
rect.w:= w; 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

901 
rect.x:= ViewLeftX; 
10627  902 
DrawRect(rect, $10, $10, $10, $80, true); 
10360
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

903 
if WorldEdge = weBounce then 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

904 
DrawLineOnScreen(tmp  1, ViewTopY, tmp  1, ViewBottomY, 2, $54, $54, $FF, $FF); 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

905 
end; 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

906 

10494  907 
tmp:= LongInt(rightX) + WorldDx; 
10360
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

908 
w:= ViewRightX  tmp; 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

909 

c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

910 
if w > 0 then 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

911 
begin 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

912 
rect.w:= w; 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

913 
rect.x:= tmp; 
10627  914 
DrawRect(rect, $10, $10, $10, $80, true); 
10360
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

915 
if WorldEdge = weBounce then 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

916 
DrawLineOnScreen(tmp  1, ViewTopY, tmp  1, ViewBottomY, 2, $54, $54, $FF, $FF); 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

917 
end; 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

918 

c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

919 
(* 
10523
00ac079fa51f
fix some nasty rendering issues reported by Nexia  thanks a lot!
sheepluva
parents:
10510
diff
changeset

920 
WARNING: the following render code is outdated and does not work with 
00ac079fa51f
fix some nasty rendering issues reported by Nexia  thanks a lot!
sheepluva
parents:
10510
diff
changeset

921 
current Render.pas !  don't just uncomment without fixing it first 
00ac079fa51f
fix some nasty rendering issues reported by Nexia  thanks a lot!
sheepluva
parents:
10510
diff
changeset

922 

9654  923 
glDisable(GL_TEXTURE_2D); 
924 
glDisableClientState(GL_TEXTURE_COORD_ARRAY); 

10360
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

925 
if (WorldEdge = weWrap) or (worldEdge = weBounce) then 
10275
6c91047f59b6
RAR: cleaning up a bit of the IFDEFclusterf*ck
sheepluva
parents:
10265
diff
changeset

926 
glColor4ub($00, $00, $00, $40) 
10265
7e8d4cd76ce7
darken wrapped areas, which was a very nice suggestion by nemo
sheepluva
parents:
10263
diff
changeset

927 
else 
7e8d4cd76ce7
darken wrapped areas, which was a very nice suggestion by nemo
sheepluva
parents:
10263
diff
changeset

928 
begin 
7e8d4cd76ce7
darken wrapped areas, which was a very nice suggestion by nemo
sheepluva
parents:
10263
diff
changeset

929 
glEnableClientState(GL_COLOR_ARRAY); 
7e8d4cd76ce7
darken wrapped areas, which was a very nice suggestion by nemo
sheepluva
parents:
10263
diff
changeset

930 
glColorPointer(4, GL_UNSIGNED_BYTE, 0, @WorldFade[0]); 
7e8d4cd76ce7
darken wrapped areas, which was a very nice suggestion by nemo
sheepluva
parents:
10263
diff
changeset

931 
end; 
9654  932 

933 
glPushMatrix; 

934 
glTranslatef(WorldDx, WorldDy, 0); 

935 

936 
VertexBuffer[0].X:= leftX20; 

10265
7e8d4cd76ce7
darken wrapped areas, which was a very nice suggestion by nemo
sheepluva
parents:
10263
diff
changeset

937 
VertexBuffer[0].Y:= 3500; 
9654  938 
VertexBuffer[1].X:= leftX20; 
939 
VertexBuffer[1].Y:= cWaterLine+cVisibleWater; 

940 
VertexBuffer[2].X:= leftX+30; 

941 
VertexBuffer[2].Y:= cWaterLine+cVisibleWater; 

942 
VertexBuffer[3].X:= leftX+30; 

10265
7e8d4cd76ce7
darken wrapped areas, which was a very nice suggestion by nemo
sheepluva
parents:
10263
diff
changeset

943 
VertexBuffer[3].Y:= 3500; 
9654  944 

945 
glVertexPointer(2, GL_FLOAT, 0, @VertexBuffer[0]); 

946 
glDrawArrays(GL_TRIANGLE_FAN, 0, Length(VertexBuffer)); 

947 

948 
VertexBuffer[0].X:= rightX+20; 

949 
VertexBuffer[1].X:= rightX+20; 

950 
VertexBuffer[2].X:= rightX30; 

951 
VertexBuffer[3].X:= rightX30; 

952 

953 
glVertexPointer(2, GL_FLOAT, 0, @VertexBuffer[0]); 

954 
glDrawArrays(GL_TRIANGLE_FAN, 0, Length(VertexBuffer)); 

955 

956 
glColorPointer(4, GL_UNSIGNED_BYTE, 0, @WorldEnd[0]); 

957 

958 
VertexBuffer[0].X:= 5000; 

959 
VertexBuffer[1].X:= 5000; 

960 
VertexBuffer[2].X:= leftX20; 

961 
VertexBuffer[3].X:= leftX20; 

962 

963 
glVertexPointer(2, GL_FLOAT, 0, @VertexBuffer[0]); 

964 
glDrawArrays(GL_TRIANGLE_FAN, 0, Length(VertexBuffer)); 

965 

966 
VertexBuffer[0].X:= rightX+5000; 

967 
VertexBuffer[1].X:= rightX+5000; 

968 
VertexBuffer[2].X:= rightX+20; 

969 
VertexBuffer[3].X:= rightX+20; 

970 

971 
glVertexPointer(2, GL_FLOAT, 0, @VertexBuffer[0]); 

972 
glDrawArrays(GL_TRIANGLE_FAN, 0, Length(VertexBuffer)); 

973 

974 
glPopMatrix; 

975 
glDisableClientState(GL_COLOR_ARRAY); 

976 
glEnableClientState(GL_TEXTURE_COORD_ARRAY); 

977 

978 
glColor4ub($FF, $FF, $FF, $FF); // must not be Tint() as color array seems to stay active and color reset is required 

979 
glEnable(GL_TEXTURE_2D); 

980 

10015  981 
// I'd still like to have things happen to the border when a wrap or bounce just occurred, based on a timer 
9654  982 
if WorldEdge = weBounce then 
983 
begin 

984 
// could maybe alternate order of these on a bounce, or maybe drop the outer ones. 

985 
if LeftImpactTimer mod 2 = 0 then 

986 
begin 

987 
c1:= $5454FFFF; c2:= $FFFFFFFF; 

988 
end 

989 
else begin 

990 
c1:= $FFFFFFFF; c2:= $5454FFFF; 

991 
end; 

992 
DrawLine(leftX, 3000, leftX, cWaterLine+cVisibleWater, 7.0, c1); 

993 
DrawLine(leftX, 3000, leftX, cWaterLine+cVisibleWater, 5.0, c2); 

994 
DrawLine(leftX, 3000, leftX, cWaterLine+cVisibleWater, 3.0, c1); 

995 
DrawLine(leftX, 3000, leftX, cWaterLine+cVisibleWater, 1.0, c2); 

996 
if RightImpactTimer mod 2 = 0 then 

997 
begin 

998 
c1:= $5454FFFF; c2:= $FFFFFFFF; 

999 
end 

1000 
else begin 

1001 
c1:= $FFFFFFFF; c2:= $5454FFFF; 

1002 
end; 

1003 
DrawLine(rightX, 3000, rightX, cWaterLine+cVisibleWater, 7.0, c1); 

1004 
DrawLine(rightX, 3000, rightX, cWaterLine+cVisibleWater, 5.0, c2); 

1005 
DrawLine(rightX, 3000, rightX, cWaterLine+cVisibleWater, 3.0, c1); 

1006 
DrawLine(rightX, 3000, rightX, cWaterLine+cVisibleWater, 1.0, c2) 

1007 
end 

1008 
else if WorldEdge = weWrap then 

1009 
begin 

10360
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

1010 
DrawLine(leftX, 3000, leftX, cWaterLine+cVisibleWater, 5.0, $A0, $30, $60, max(50,255LeftImpactTimer)); 
9654  1011 
DrawLine(leftX, 3000, leftX, cWaterLine+cVisibleWater, 2.0, $FF0000FF); 
1012 
DrawLine(rightX, 3000, rightX, cWaterLine+cVisibleWater, 5.0, $A0, $30, $60, max(50,255RightImpactTimer)); 

10360
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

1013 
DrawLine(rightX, 3000, rightX, cWaterLine+cVisibleWater, 2.0, $FF0000FF); 
9654  1014 
end 
1015 
else 

1016 
begin 

1017 
DrawLine(leftX, 3000, leftX, cWaterLine+cVisibleWater, 5.0, $2E8B5780); 

1018 
DrawLine(rightX, 3000, rightX, cWaterLine+cVisibleWater, 5.0, $2E8B5780) 

1019 
end; 

1020 
if LeftImpactTimer > Lag then dec(LeftImpactTimer,Lag) else LeftImpactTimer:= 0; 

1021 
if RightImpactTimer > Lag then dec(RightImpactTimer,Lag) else RightImpactTimer:= 0 

10360
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

1022 
*) 
9654  1023 
end; 
1024 
end; 

1025 

1026 

1027 
procedure RenderTeamsHealth; 

9720
453a1c29b7e4
Animate hedgehogs healths inside team health bar. Proper animation for the case when max team health grows is lost though.
unc0rr
parents:
9693
diff
changeset

1028 
var t, i, h, smallScreenOffset, TeamHealthBarWidth : LongInt; 
9654  1029 
r: TSDL_Rect; 
1030 
highlight: boolean; 

9656  1031 
htex: PTexture; 
9654  1032 
begin 
1033 
if TeamsCount * 20 > Longword(cScreenHeight) div 7 then // take up less screen on small displays 

1034 
begin 

1035 
SetScale(1.5); 

1036 
smallScreenOffset:= cScreenHeight div 6; 

1037 
if TeamsCount * 100 > Longword(cScreenHeight) then 

1038 
Tint($FF,$FF,$FF,$80); 

1039 
end 

1040 
else smallScreenOffset:= 0; 

1041 
for t:= 0 to Pred(TeamsCount) do 

1042 
with TeamsArray[t]^ do 

1043 
if TeamHealth > 0 then 

1044 
begin 

1045 
highlight:= bShowFinger and (CurrentTeam = TeamsArray[t]) and ((RealTicks mod 1000) < 500); 

1046 

1047 
if highlight then 

9656  1048 
begin 
9654  1049 
Tint(Clan^.Color shl 8 or $FF); 
9656  1050 
htex:= GenericHealthTexture 
1051 
end 

1052 
else 

1053 
htex:= Clan^.HealthTex; 

9654  1054 

9791
446e4919b738
Display team owner in teams widget (addresses issue 174)
unc0rr
parents:
9755
diff
changeset

1055 
// draw owner 
446e4919b738
Display team owner in teams widget (addresses issue 174)
unc0rr
parents:
9755
diff
changeset

1056 
if OwnerTex <> nil then 
446e4919b738
Display team owner in teams widget (addresses issue 174)
unc0rr
parents:
9755
diff
changeset

1057 
DrawTexture(OwnerTex^.w  NameTagTex^.w  18, cScreenHeight + DrawHealthY + smallScreenOffset, OwnerTex); 
446e4919b738
Display team owner in teams widget (addresses issue 174)
unc0rr
parents:
9755
diff
changeset

1058 

446e4919b738
Display team owner in teams widget (addresses issue 174)
unc0rr
parents:
9755
diff
changeset

1059 
// draw name 
9654  1060 
DrawTexture(NameTagTex^.w  16, cScreenHeight + DrawHealthY + smallScreenOffset, NameTagTex); 
1061 

1062 
// draw flag 

1063 
DrawTexture(14, cScreenHeight + DrawHealthY + smallScreenOffset, FlagTex); 

1064 

9720
453a1c29b7e4
Animate hedgehogs healths inside team health bar. Proper animation for the case when max team health grows is lost though.
unc0rr
parents:
9693
diff
changeset

1065 
TeamHealthBarWidth:= cTeamHealthWidth * TeamHealthBarHealth div MaxTeamHealth; 
453a1c29b7e4
Animate hedgehogs healths inside team health bar. Proper animation for the case when max team health grows is lost though.
unc0rr
parents:
9693
diff
changeset

1066 

9654  1067 
// draw health bar 
1068 
r.x:= 0; 

1069 
r.y:= 0; 

1070 
r.w:= 2 + TeamHealthBarWidth; 

9656  1071 
r.h:= htex^.h; 
1072 
DrawTextureFromRect(14, cScreenHeight + DrawHealthY + smallScreenOffset, @r, htex); 

9654  1073 

1074 
// draw health bars right border 

1075 
inc(r.x, cTeamHealthWidth + 2); 

1076 
r.w:= 3; 

9656  1077 
DrawTextureFromRect(TeamHealthBarWidth + 15, cScreenHeight + DrawHealthY + smallScreenOffset, @r, htex); 
9654  1078 

9720
453a1c29b7e4
Animate hedgehogs healths inside team health bar. Proper animation for the case when max team health grows is lost though.
unc0rr
parents:
9693
diff
changeset

1079 
h:= 0; 
9654  1080 
if not hasGone then 
1081 
for i:= 0 to cMaxHHIndex do 

9720
453a1c29b7e4
Animate hedgehogs healths inside team health bar. Proper animation for the case when max team health grows is lost though.
unc0rr
parents:
9693
diff
changeset

1082 
begin 
453a1c29b7e4
Animate hedgehogs healths inside team health bar. Proper animation for the case when max team health grows is lost though.
unc0rr
parents:
9693
diff
changeset

1083 
inc(h, Hedgehogs[i].HealthBarHealth); 
10015  1084 
if (h < TeamHealthBarHealth) and (Hedgehogs[i].HealthBarHealth > 0) then 
9720
453a1c29b7e4
Animate hedgehogs healths inside team health bar. Proper animation for the case when max team health grows is lost though.
unc0rr
parents:
9693
diff
changeset

1085 
DrawTexture(15 + h * TeamHealthBarWidth div TeamHealthBarHealth, cScreenHeight + DrawHealthY + smallScreenOffset + 1, SpritesData[sprSlider].Texture); 
453a1c29b7e4
Animate hedgehogs healths inside team health bar. Proper animation for the case when max team health grows is lost though.
unc0rr
parents:
9693
diff
changeset

1086 
end; 
9654  1087 

1088 
// draw ai kill counter for gfAISurvival 

1089 
if (GameFlags and gfAISurvival) <> 0 then 

1090 
begin 

1091 
DrawTexture(TeamHealthBarWidth + 22, cScreenHeight + DrawHealthY + smallScreenOffset, AIKillsTex); 

1092 
end; 

1093 

1094 
// if highlighted, draw flag and other contents again to keep their colors 

1095 
// this approach should be faster than drawing all borders one by one tinted or not 

1096 
if highlight then 

1097 
begin 

1098 
if TeamsCount * 100 > Longword(cScreenHeight) then 

1099 
Tint($FF,$FF,$FF,$80) 

9666
8dcb25112d96
 Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9656
diff
changeset

1100 
else untint; 
9654  1101 

1102 
// draw name 

1103 
r.x:= 2; 

1104 
r.y:= 2; 

1105 
r.w:= NameTagTex^.w  4; 

1106 
r.h:= NameTagTex^.h  4; 

1107 
DrawTextureFromRect(NameTagTex^.w  14, cScreenHeight + DrawHealthY + smallScreenOffset + 2, @r, NameTagTex); 

10147  1108 

1109 
if OwnerTex <> nil then 

1110 
begin 

1111 
r.w:= OwnerTex^.w  4; 

1112 
r.h:= OwnerTex^.h  4; 

1113 
DrawTextureFromRect(OwnerTex^.w  NameTagTex^.w  16, cScreenHeight + DrawHealthY + smallScreenOffset + 2, @r, OwnerTex) 

1114 
end; 

1115 

1116 
if (GameFlags and gfAISurvival) <> 0 then 

1117 
begin 

1118 
r.w:= AIKillsTex^.w  4; 

1119 
r.h:= AIKillsTex^.h  4; 

1120 
DrawTextureFromRect(TeamHealthBarWidth + 24, cScreenHeight + DrawHealthY + smallScreenOffset + 2, @r, AIKillsTex); 

1121 
end; 

1122 

9654  1123 
// draw flag 
1124 
r.w:= 22; 

1125 
r.h:= 15; 

1126 
DrawTextureFromRect(12, cScreenHeight + DrawHealthY + smallScreenOffset + 2, @r, FlagTex); 

10317  1127 
end 
1128 
// draw an arrow next to active team 

1129 
else if (CurrentTeam = TeamsArray[t]) and (TurnTimeLeft > 0) then 

1130 
begin 

1131 
h:= NameTagTex^.w  24; 

1132 
if OwnerTex <> nil then 

1133 
h:= h  OwnerTex^.w  4; 

1134 
DrawSpriteRotatedF(sprFinger, h, cScreenHeight + DrawHealthY + smallScreenOffset + 2 + SpritesData[sprFinger].Width div 4, 0, 1, 90); 

9654  1135 
end; 
1136 
end; 

1137 
if smallScreenOffset <> 0 then 

1138 
begin 

1139 
SetScale(cDefaultZoomLevel); 

1140 
if TeamsCount * 20 > Longword(cScreenHeight) div 5 then 

10032
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
10009
diff
changeset

1141 
untint; 
9654  1142 
end; 
1143 
end; 

1144 

1145 

10360
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

1146 
var preShiftWorldDx: LongInt; 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

1147 

10507
ed5df9cd251f
I'm such a dirty boi... cleaning up my own mess a little
sheepluva
parents:
10494
diff
changeset

1148 
procedure ShiftWorld(Dir: LongInt); inline; 
10360
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

1149 
begin 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

1150 
preShiftWorldDx:= WorldDx; 
11090
874e477700d5
 Fix for "uWorld.s:4736:8: error: base register is 64bit, but index register is not leal (%rax,%edx),%eax"
antonc27 <antonc27@mail.ru>
parents:
11000
diff
changeset

1151 
WorldDx:= WorldDx + LongInt(Dir * LongInt(playWidth)); 
10360
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

1152 

c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

1153 
end; 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

1154 

10507
ed5df9cd251f
I'm such a dirty boi... cleaning up my own mess a little
sheepluva
parents:
10494
diff
changeset

1155 
procedure UnshiftWorld(); inline; 
10360
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

1156 
begin 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

1157 
WorldDx:= preShiftWorldDx; 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

1158 
end; 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

1159 

3692  1160 
procedure DrawWorldStereo(Lag: LongInt; RM: TRenderMode); 
9654  1161 
var i, t: LongInt; 
3692  1162 
r: TSDL_Rect; 
1163 
tdx, tdy: Double; 

7016  1164 
s: shortstring; 
9654  1165 
offsetX, offsetY, screenBottom: LongInt; 
10507
ed5df9cd251f
I'm such a dirty boi... cleaning up my own mess a little
sheepluva
parents:
10494
diff
changeset

1166 
replicateToLeft, replicateToRight, tmp: boolean; 
10871  1167 
a: Byte; 
10358  1168 
begin 
10507
ed5df9cd251f
I'm such a dirty boi... cleaning up my own mess a little
sheepluva
parents:
10494
diff
changeset

1169 
if WorldEdge <> weWrap then 
10360
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

1170 
begin 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

1171 
replicateToLeft := false; 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

1172 
replicateToRight:= false; 
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

1173 
end 
10358  1174 
else 
10360
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

1175 
begin 
10494  1176 
replicateToLeft := (LongInt(leftX) + WorldDx > ViewLeftX); 
1177 
replicateToRight:= (LongInt(rightX) + WorldDx < ViewRightX); 

10360
c243b6a8ad9a
some adjustments and support for mirrored world rendering. disabled atm though, I think it is more confusing than helping
sheepluva
parents:
10359
diff
changeset

1178 
end; 
10358  1179 

10318  1180 
ScreenBottom:= (WorldDy  trunc(cScreenHeight/cScaleFactor)  (cScreenHeight div 2) + cWaterLine); 
1181 

1182 
// note: offsetY is negative! 

10319  1183 
offsetY:= 10 * Min(0, 145  ScreenBottom); // TODO limit this in the other direction too 
10318  1184 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

1185 
if (cReducedQuality and rqNoBackground) = 0 then 
1812  1186 
begin 
3594
aeca3d8f1b29
turn cReducedQuality into a LongInt and provide a series of quality flags (and best of all, this is still compatible with current frontend)
koda
parents:
3582
diff
changeset

1187 
// Offsets relative to camera  spare them to wimpier cpus, no bg or flakes for them anyway 
aeca3d8f1b29
turn cReducedQuality into a LongInt and provide a series of quality flags (and best of all, this is still compatible with current frontend)
koda
parents:
3582
diff
changeset

1188 
SkyOffset:= offsetY div 35 + cWaveHeight; 
aeca3d8f1b29
turn cReducedQuality into a LongInt and provide a series of quality flags (and best of all, this is still compatible with current frontend)
koda
parents:
3582
diff
changeset

1189 
HorizontOffset:= SkyOffset; 
aeca3d8f1b29
turn cReducedQuality into a LongInt and provide a series of quality flags (and best of all, this is still compatible with current frontend)
koda
parents:
3582
diff
changeset

1190 
if ScreenBottom > SkyOffset then 
aeca3d8f1b29
turn cReducedQuality into a LongInt and provide a series of quality flags (and best of all, this is still compatible with current frontend)
koda
parents:
3582
diff
changeset

1191 
HorizontOffset:= HorizontOffset + ((ScreenBottomSkyOffset) div 20); 
3265
5fe62296fdea
 Parallax effect for horizont when water is out of sight
palewolf
parents:
3249
diff
changeset

1192 

3594
aeca3d8f1b29
turn cReducedQuality into a LongInt and provide a series of quality flags (and best of all, this is still compatible with current frontend)
koda
parents:
3582
diff
changeset

1193 
// background 
3688  1194 
ChangeDepth(RM, cStereo_Sky); 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

1195 
if SuddenDeathDmg then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

1196 
Tint(SDTint, SDTint, SDTint, $FF); 
3594
aeca3d8f1b29
turn cReducedQuality into a LongInt and provide a series of quality flags (and best of all, this is still compatible with current frontend)
koda
parents:
3582
diff
changeset

1197 
DrawRepeated(sprSky, sprSkyL, sprSkyR, (WorldDx + LAND_WIDTH div 2) * 3 div 8, SkyOffset); 
3688  1198 
ChangeDepth(RM, cStereo_Horizon); 
3594
aeca3d8f1b29
turn cReducedQuality into a LongInt and provide a series of quality flags (and best of all, this is still compatible with current frontend)
koda
parents:
3582
diff
changeset

1199 
DrawRepeated(sprHorizont, sprHorizontL, sprHorizontR, (WorldDx + LAND_WIDTH div 2) * 3 div 5, HorizontOffset); 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

1200 
if SuddenDeathDmg then 
9666
8dcb25112d96
 Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9656
diff
changeset

1201 
untint; 
3611  1202 
end; 
4  1203 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

1204 
DrawVisualGears(0); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

1205 
ChangeDepth(RM, cStereo_MidDistance); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

1206 
DrawVisualGears(4); 
3697  1207 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

1208 
if (cReducedQuality and rq2DWater) = 0 then 
3611  1209 
begin 
3594
aeca3d8f1b29
turn cReducedQuality into a LongInt and provide a series of quality flags (and best of all, this is still compatible with current frontend)
koda
parents:
3582
diff
changeset

1210 
// Waves 
10318  1211 
DrawWater(255, SkyOffset, 0); 
4816
c2575faeac3d
use a different depth for different layers (land, water, explosions)
koda
parents:
4812
diff
changeset

1212 
ChangeDepth(RM, cStereo_Water_distant); 
10318  1213 
DrawWaves( 1, 0  WorldDx div 32, offsetY div 35, 49, 64); 
4816
c2575faeac3d
use a different depth for different layers (land, water, explosions)
koda
parents:
4812
diff
changeset

1214 
ChangeDepth(RM, cStereo_Water_distant); 
10318  1215 
DrawWaves( 1, 25 + WorldDx div 25, offsetY div 38, 37, 48); 
4816
c2575faeac3d
use a different depth for different layers (land, water, explosions)
koda
parents:
4812
diff
changeset

1216 
ChangeDepth(RM, cStereo_Water_distant); 
10318  1217 
DrawWaves( 1, 75  WorldDx div 19, offsetY div 45, 23, 32); 
4816
c2575faeac3d
use a different depth for different layers (land, water, explosions)
koda
parents:
4812
diff
changeset

1218 
ChangeDepth(RM, cStereo_Water_distant); 
10318  1219 
DrawWaves(1, 100 + WorldDx div 14, offsetY div 70, 7, 24); 
3265
5fe62296fdea
 Parallax effect for horizont when water is out of sight
palewolf
parents:
3249
diff
changeset

1220 
end 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

1221 
else 
10318  1222 
DrawWaves(1, 100,  cWaveHeight div 2,  cWaveHeight div 2, 0); 
4  1223 

10533  1224 
ChangeDepth(RM, cStereo_Land); 
1225 
DrawVisualGears(5); 

1226 
DrawLand(WorldDx, WorldDy); 

10358  1227 

10533  1228 
if replicateToLeft then 
1229 
begin 

1230 
ShiftWorld(1); 

1231 
DrawLand(WorldDx, WorldDy); 

1232 
UnshiftWorld(); 

1233 
end; 

10358  1234 

10533  1235 
if replicateToRight then 
1236 
begin 

1237 
ShiftWorld(1); 

1238 
DrawLand(WorldDx, WorldDy); 

1239 
UnshiftWorld(); 

1240 
end; 

1911  1241 

10533  1242 
DrawWater(255, 0, 0); 
4  1243 

8026
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7946
diff
changeset

1244 
(* 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7946
diff
changeset

1245 
// Attack bar 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7946
diff
changeset

1246 
if CurrentTeam <> nil then 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7946
diff
changeset

1247 
case AttackBar of 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7946
diff
changeset

1248 
//1: begin 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7946
diff
changeset

1249 
//r:= StuffPoz[sPowerBar]; 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7946
diff
changeset

1250 
//{$WARNINGS OFF} 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7946
diff
changeset

1251 
//r.w:= (CurrentHedgehog^.Gear^.Power * 256) div cPowerDivisor; 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7946
diff
changeset

1252 
//{$WARNINGS ON} 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7946
diff
changeset

1253 
//DrawSpriteFromRect(r, cScreenWidth  272, cScreenHeight  48, 16, 0, Surface); 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7946
diff
changeset

1254 
//end; 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7946
diff
changeset

1255 
2: with CurrentHedgehog^ do 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7946
diff
changeset

1256 
begin 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7946
diff
changeset

1257 
tdx:= hwSign(Gear^.dX) * Sin(Gear^.Angle * Pi / cMaxAngle); 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7946
diff
changeset

1258 
tdy:=  Cos(Gear^.Angle * Pi / cMaxAngle); 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7946
diff
changeset

1259 
for i:= (Gear^.Power * 24) div cPowerDivisor downto 0 do 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7946
diff
changeset

1260 
DrawSprite(sprPower, 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7946
diff
changeset

1261 
hwRound(Gear^.X) + GetLaunchX(CurAmmoType, hwSign(Gear^.dX), Gear^.Angle) + LongInt(round(WorldDx + tdx * (24 + i * 2)))  16, 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7946
diff
changeset

1262 
hwRound(Gear^.Y) + GetLaunchY(CurAmmoType, Gear^.Angle) + LongInt(round(WorldDy + tdy * (24 + i * 2)))  16, 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7946
diff
changeset

1263 
i) 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7946
diff
changeset

1264 
end 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7946
diff
changeset

1265 
end; 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7946
diff
changeset

1266 
*) 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7946
diff
changeset

1267 

10359  1268 
tmp:= bShowFinger; 
1269 
bShowFinger:= false; 

1270 

10358  1271 
if replicateToLeft then 
10263
6ef900411158
here a personal experimental mockup of how I imagine wrapping world edges should look like. bouncing one could be similar just with mirrored stuff. please test and share opinion. note: you might wanna disable autocam
sheepluva
parents:
10251
diff
changeset

1272 
begin 
10507
ed5df9cd251f
I'm such a dirty boi... cleaning up my own mess a little
sheepluva
parents:
10494
diff
changeset

1273 
ShiftWorld(1); 
10263
6ef900411158
here a personal experimental mockup of how I imagine wrapping world edges should look like. bouncing one could be similar just with mirrored stuff. please test and share opinion. note: you might wanna disable autocam
sheepluva
parents:
10251
diff
changeset

1274 
DrawVisualGears(1); 
6ef900411158
here a personal experimental mockup of how I imagine wrapping world edges should look like. bouncing one could be similar just with mirrored stuff. please test and share opinion. note: you might wanna disable autocam
sheepluva
parents:
10251
diff
changeset

1275 
DrawGears(); 
6ef900411158
here a personal experimental mockup of how I imagine wrapping world edges should look like. bouncing one could be similar just with mirrored stuff. please test and share opinion. note: you might wanna disable autocam
sheepluva
parents:
10251
diff
changeset

1276 
DrawVisualGears(6); 
10507
ed5df9cd251f
I'm such a dirty boi... cleaning up my own mess a little
sheepluva
parents:
10494
diff
changeset

1277 
UnshiftWorld(); 
10358  1278 
end; 
1279 

1280 
if replicateToRight then 

1281 
begin 

10507
ed5df9cd251f
I'm such a dirty boi... cleaning up my own mess a little
sheepluva
parents:
10494
diff
changeset

1282 
ShiftWorld(1); 
10263
6ef900411158
here a personal experimental mockup of how I imagine wrapping world edges should look like. bouncing one could be similar just with mirrored stuff. please test and share opinion. note: you might wanna disable autocam
sheepluva
parents:
10251
diff
changeset

1283 
DrawVisualGears(1); 
6ef900411158
here a personal experimental mockup of how I imagine wrapping world edges should look like. bouncing one could be similar just with mirrored stuff. please test and share opinion. note: you might wanna disable autocam
sheepluva
parents:
10251
diff
changeset

1284 
DrawGears(); 
6ef900411158
here a personal experimental mockup of how I imagine wrapping world edges should look like. bouncing one could be similar just with mirrored stuff. please test and share opinion. note: you might wanna disable autocam
sheepluva
parents:
10251
diff
changeset

1285 
DrawVisualGears(6); 
10507
ed5df9cd251f
I'm such a dirty boi... cleaning up my own mess a little
sheepluva
parents:
10494
diff
changeset

1286 
UnshiftWorld(); 
10263
6ef900411158
here a personal experimental mockup of how I imagine wrapping world edges should look like. bouncing one could be similar just with mirrored stuff. please test and share opinion. note: you might wanna disable autocam
sheepluva
parents:
10251
diff
changeset

1287 
end; 
6ef900411158
here a personal experimental mockup of how I imagine wrapping world edges should look like. bouncing one could be similar just with mirrored stuff. please test and share opinion. note: you might wanna disable autocam
sheepluva
parents:
10251
diff
changeset

1288 

10359  1289 
bShowFinger:= tmp; 
1290 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

1291 
DrawVisualGears(1); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

1292 
DrawGears; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

1293 
DrawVisualGears(6); 
4  1294 

10263
6ef900411158
here a personal experimental mockup of how I imagine wrapping world edges should look like. bouncing one could be similar just with mirrored stuff. please test and share opinion. note: you might wanna disable autocam
sheepluva
parents:
10251
diff
changeset

1295 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

1296 
if SuddenDeathDmg then 
10318  1297 
DrawWater(SDWaterOpacity, 0, 0) 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

1298 
else 
10318  1299 
DrawWater(WaterOpacity, 0, 0); 
2269
00f5704f5f39
add extra semiopaque layer of water to discolour objects in the water.
nemo
parents:
2268
diff
changeset

1300 

3611  1301 
// Waves 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

1302 
ChangeDepth(RM, cStereo_Water_near); 
10318  1303 
DrawWaves( 1, 25  WorldDx div 9, 0, 0, 12); 
3265
5fe62296fdea
 Parallax effect for horizont when water is out of sight
palewolf
parents:
3249
diff
changeset

1304 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

1305 
if (cReducedQuality and rq2DWater) = 0 then 
3265
5fe62296fdea
 Parallax effect for horizont when water is out of sight
palewolf
parents:
3249
diff
changeset

1306 
begin 
6982  1307 
//DrawWater(WaterOpacity,  offsetY div 40); 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

1308 
ChangeDepth(RM, cStereo_Water_near); 
10318  1309 
DrawWaves(1, 50 + WorldDx div 6,  offsetY div 40, 23, 8); 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

1310 
if SuddenDeathDmg then 
10318  1311 
DrawWater(SDWaterOpacity,  offsetY div 20, 23) 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

1312 
else 
10318  1313 
DrawWater(WaterOpacity,  offsetY div 20, 23); 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6492
diff
changeset

1314 
ChangeDepth(RM, cStereo_Water_near); 
10318  1315 
DrawWaves( 1, 75  WorldDx div 4,  offsetY div 20, 37, 2); 
4792
68f9b331014a
sudden death changes: only change visual bit on health decrease and support for water transparancy change and clouds number change
Henek
parents:
4748
diff
changeset

1316 
if SuddenDeathDmg then 
10318  1317 
DrawWater(SDWaterOpacity,  offsetY div 10, 47) 
4792
68f9b331014a
sudden death changes: only change visual bit on health decrease and support for water transparancy change and clouds number change
Henek
parents:
4748
diff
changeset

1318 
else 
10318 