author  sheepluva 
Wed, 17 Dec 2014 19:23:57 +0100  
changeset 10690  c3b73dc33294 
parent 10605  df7a73db2c43 
child 10748  dc587913987c 
child 11046  47a8c19ecb60 
permissions  rwrr 
4976  1 
(* 
2 
* Hedgewars, a free turn based strategy game 

9998  3 
* Copyright (c) 20042014 Andrey Korotaev <unC0Rr@gmail.com> 
4976  4 
* 
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 

8 
* 

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. 

13 
* 

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:
10104
diff
changeset

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

4374  19 
{$INCLUDE "options.inc"} 
4976  20 

4374  21 
unit uUtils; 
22 

23 
interface 

9295
f8819c3dde54
Remove some GLunit dependencies noticed on graph. uUtils was using it for GLfloat  but, the stuff it was returning to was usually converting to "real" anyway. uLand was including it unnecessarily. Minor refactor
nemo
parents:
9080
diff
changeset

24 
uses uTypes, uFloat; 
4374  25 

26 
procedure SplitBySpace(var a, b: shortstring); 

7191
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7151
diff
changeset

27 
procedure SplitByChar(var a, b: shortstring; c: char); 
10131
4b4a043111f4
 pas2c recognizes typecasts in initialization expressions
unc0rr
parents:
10127
diff
changeset

28 
procedure SplitByCharA(var a, b: ansistring; c: char); 
4374  29 

30 
function EnumToStr(const en : TGearType) : shortstring; overload; 

4453  31 
function EnumToStr(const en : TVisualGearType) : shortstring; overload; 
4374  32 
function EnumToStr(const en : TSound) : shortstring; overload; 
33 
function EnumToStr(const en : TAmmoType) : shortstring; overload; 

9642
8a691e0f117a
use consts for TStatInfo enum
Periklis Ntanasis <pntanasis@gmail.com>
parents:
9377
diff
changeset

34 
function EnumToStr(const en : TStatInfoType) : shortstring; overload; 
4374  35 
function EnumToStr(const en : THogEffect) : shortstring; overload; 
5118  36 
function EnumToStr(const en : TCapGroup) : shortstring; overload; 
10280
762c256552e9
WIP: PlaceSprite for lua API. also changed PlaceGirder so that it will return true/false for whether placing was successful too
sheepluva
parents:
10131
diff
changeset

37 
function EnumToStr(const en : TSprite) : shortstring; overload; 
10603
bda5c7caf396
switch mapgen to enum. should still try and make sure the values are backwards compatible if possible.
nemo
parents:
10595
diff
changeset

38 
function EnumToStr(const en : TMapGen) : shortstring; overload; 
4374  39 

40 
function Min(a, b: LongInt): LongInt; inline; 

10562  41 
function MinD(a, b: double) : double; inline; 
4374  42 
function Max(a, b: LongInt): LongInt; inline; 
43 

44 
function IntToStr(n: LongInt): shortstring; 

7151  45 
function StrToInt(s: shortstring): LongInt; 
4374  46 
function FloatToStr(n: hwFloat): shortstring; 
47 

9295
f8819c3dde54
Remove some GLunit dependencies noticed on graph. uUtils was using it for GLfloat  but, the stuff it was returning to was usually converting to "real" anyway. uLand was including it unnecessarily. Minor refactor
nemo
parents:
9080
diff
changeset

48 
function DxDy2Angle(const _dY, _dX: hwFloat): real; inline; 
4374  49 
function DxDy2Angle32(const _dY, _dX: hwFloat): LongInt; 
50 
function DxDy2AttackAngle(const _dY, _dX: hwFloat): LongInt; 

6894  51 
function DxDy2AttackAnglef(const _dY, _dX: extended): LongInt; 
4374  52 

53 
procedure SetLittle(var r: hwFloat); 

54 

55 
function Str2PChar(const s: shortstring): PChar; 

56 
function DecodeBase64(s: shortstring): shortstring; 

57 

58 
function isPowerOf2(i: Longword): boolean; 

59 
function toPowerOf2(i: Longword): Longword; inline; 

60 

61 
function endian(independent: LongWord): LongWord; inline; 

62 

10116
dd27562b6f21
rolling back my PChar stuff, because unC0Rr improves string handling pas2c instead <3
sheepluva
parents:
10108
diff
changeset

63 
function CheckCJKFont(s: ansistring; font: THWFont): THWFont; 
4380  64 

4374  65 
procedure AddFileLog(s: shortstring); 
7180  66 
procedure AddFileLogRaw(s: pchar); cdecl; 
4374  67 

4900  68 
function CheckNoTeamOrHH: boolean; inline; 
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4385
diff
changeset

69 

4403  70 
function GetLaunchX(at: TAmmoType; dir: LongInt; angle: LongInt): LongInt; 
71 
function GetLaunchY(at: TAmmoType; angle: LongInt): LongInt; 

72 

7151  73 
{$IFNDEF PAS2C} 
74 
procedure Write(var f: textfile; s: shortstring); 

75 
procedure WriteLn(var f: textfile; s: shortstring); 

10080  76 
function StrLength(s: PChar): Longword; 
10690  77 
procedure SetLengthA(var s: ansistring; len: Longword); 
7151  78 
{$ENDIF} 
79 

8204  80 
function isPhone: Boolean; inline; 
81 

82 
{$IFDEF IPHONEOS} 

83 
procedure startLoadingIndicator; cdecl; external; 

84 
procedure stopLoadingIndicator; cdecl; external; 

85 
procedure saveFinishedSynching; cdecl; external; 

86 
function isApplePhone: Boolean; cdecl; external; 

87 
procedure AudioServicesPlaySystemSound(num: LongInt); cdecl; external; 

88 
{$ENDIF} 

89 

8498
eecadca7db50
Bring back full log strings for commands, just a bit sanitized
unc0rr
parents:
8425
diff
changeset

90 
function sanitizeForLog(s: shortstring): shortstring; 
eecadca7db50
Bring back full log strings for commands, just a bit sanitized
unc0rr
parents:
8425
diff
changeset

91 
function sanitizeCharForLog(c: char): shortstring; 
eecadca7db50
Bring back full log strings for commands, just a bit sanitized
unc0rr
parents:
8425
diff
changeset

92 

7896
67217e6108fd
another stake at variable preinitialisation  we lost preview logging in the course
koda
parents:
7565
diff
changeset

93 
procedure initModule(isNotPreview: boolean); 
4374  94 
procedure freeModule; 
95 

4385  96 

4374  97 
implementation 
7043
7c080e5ac8d0
Some work to make more units compile after conversion to c
unc0rr
parents:
7028
diff
changeset

98 
uses {$IFNDEF PAS2C}typinfo, {$ENDIF}Math, uConsts, uVariables, SysUtils; 
4374  99 

100 
{$IFDEF DEBUGFILE} 

10572
c4e86a2efc55
give variable with unitwide scope a better name than just 'f'
sheepluva
parents:
10562
diff
changeset

101 
var logFile: textfile; 
7198
5debd5fe526e
1. Add IFDEFs for video recording
Stepan777 <stepik777@mail.ru>
parents:
7194
diff
changeset

102 
{$IFDEF USE_VIDEO_RECORDING} 
7180  103 
logMutex: TRTLCriticalSection; // mutex for debug file 
4374  104 
{$ENDIF} 
7198
5debd5fe526e
1. Add IFDEFs for video recording
Stepan777 <stepik777@mail.ru>
parents:
7194
diff
changeset

105 
{$ENDIF} 
8026
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7896
diff
changeset

106 
var CharArray: array[0..255] of Char; 
4374  107 

7191
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7151
diff
changeset

108 
procedure SplitBySpace(var a,b: shortstring); 
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7151
diff
changeset

109 
begin 
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7151
diff
changeset

110 
SplitByChar(a,b,' '); 
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7151
diff
changeset

111 
end; 
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7151
diff
changeset

112 

4374  113 
// should this include "strtolower()" for the split string? 
7191
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7151
diff
changeset

114 
procedure SplitByChar(var a, b: shortstring; c : char); 
4374  115 
var i, t: LongInt; 
116 
begin 

7191
9419294e5f33
first attempt at implementing support for keys with modifiers
Xeli
parents:
7151
diff
changeset

117 
i:= Pos(c, a); 
4374  118 
if i > 0 then 
119 
begin 

120 
for t:= 1 to Pred(i) do 

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

121 
if (a[t] >= 'A')and(a[t] <= 'Z') then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6444
diff
changeset

122 
Inc(a[t], 32); 
4374  123 
b:= copy(a, i + 1, Length(a)  i); 
7074  124 
a[0]:= char(Pred(i)) 
8026
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7896
diff
changeset

125 
{$IFDEF PAS2C} 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7896
diff
changeset

126 
a[i] := 0; 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7896
diff
changeset

127 
{$ENDIF} 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6444
diff
changeset

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

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

130 
b:= ''; 
4374  131 
end; 
132 

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

133 
{$IFNDEF PAS2C} 
10131
4b4a043111f4
 pas2c recognizes typecasts in initialization expressions
unc0rr
parents:
10127
diff
changeset

134 
procedure SetLengthA(var s: ansistring; len: Longword); 
4b4a043111f4
 pas2c recognizes typecasts in initialization expressions
unc0rr
parents:
10127
diff
changeset

135 
begin 
4b4a043111f4
 pas2c recognizes typecasts in initialization expressions
unc0rr
parents:
10127
diff
changeset

136 
SetLength(s, len) 
4b4a043111f4
 pas2c recognizes typecasts in initialization expressions
unc0rr
parents:
10127
diff
changeset

137 
end; 
4b4a043111f4
 pas2c recognizes typecasts in initialization expressions
unc0rr
parents:
10127
diff
changeset

138 
{$ENDIF} 
4b4a043111f4
 pas2c recognizes typecasts in initialization expressions
unc0rr
parents:
10127
diff
changeset

139 

4b4a043111f4
 pas2c recognizes typecasts in initialization expressions
unc0rr
parents:
10127
diff
changeset

140 
procedure SplitByCharA(var a, b: ansistring; c: char); 
4374  141 
var i: LongInt; 
142 
begin 

143 
i:= Pos(c, a); 

144 
if i > 0 then 

145 
begin 

146 
b:= copy(a, i + 1, Length(a)  i); 

10131
4b4a043111f4
 pas2c recognizes typecasts in initialization expressions
unc0rr
parents:
10127
diff
changeset

147 
SetLengthA(a, Pred(i)); 
4374  148 
end else b:= ''; 
10131
4b4a043111f4
 pas2c recognizes typecasts in initialization expressions
unc0rr
parents:
10127
diff
changeset

149 
end; { SplitByCharA } 
4374  150 

151 
function EnumToStr(const en : TGearType) : shortstring; overload; 

152 
begin 

153 
EnumToStr:= GetEnumName(TypeInfo(TGearType), ord(en)) 

154 
end; 

8838
aa2ffd427f6a
strip PAS2C, old WEB symbols and outdated pas2c sources from default branch, all crelated development is done on the webgl branch
koda
parents:
8575
diff
changeset

155 

4453  156 
function EnumToStr(const en : TVisualGearType) : shortstring; overload; 
157 
begin 

158 
EnumToStr:= GetEnumName(TypeInfo(TVisualGearType), ord(en)) 

159 
end; 

4374  160 

161 
function EnumToStr(const en : TSound) : shortstring; overload; 

162 
begin 

163 
EnumToStr:= GetEnumName(TypeInfo(TSound), ord(en)) 

164 
end; 

165 

166 
function EnumToStr(const en : TAmmoType) : shortstring; overload; 

167 
begin 

168 
EnumToStr:= GetEnumName(TypeInfo(TAmmoType), ord(en)) 

169 
end; 

170 

9642
8a691e0f117a
use consts for TStatInfo enum
Periklis Ntanasis <pntanasis@gmail.com>
parents:
9377
diff
changeset

171 
function EnumToStr(const en : TStatInfoType) : shortstring; overload; 
8a691e0f117a
use consts for TStatInfo enum
Periklis Ntanasis <pntanasis@gmail.com>
parents:
9377
diff
changeset

172 
begin 
8a691e0f117a
use consts for TStatInfo enum
Periklis Ntanasis <pntanasis@gmail.com>
parents:
9377
diff
changeset

173 
EnumToStr:= GetEnumName(TypeInfo(TStatInfoType), ord(en)) 
8a691e0f117a
use consts for TStatInfo enum
Periklis Ntanasis <pntanasis@gmail.com>
parents:
9377
diff
changeset

174 
end; 
8a691e0f117a
use consts for TStatInfo enum
Periklis Ntanasis <pntanasis@gmail.com>
parents:
9377
diff
changeset

175 

4374  176 
function EnumToStr(const en: THogEffect) : shortstring; overload; 
177 
begin 

5118  178 
EnumToStr := GetEnumName(TypeInfo(THogEffect), ord(en)) 
179 
end; 

180 

181 
function EnumToStr(const en: TCapGroup) : shortstring; overload; 

182 
begin 

183 
EnumToStr := GetEnumName(TypeInfo(TCapGroup), ord(en)) 

4374  184 
end; 
8838
aa2ffd427f6a
strip PAS2C, old WEB symbols and outdated pas2c sources from default branch, all crelated development is done on the webgl branch
koda
parents:
8575
diff
changeset

185 

10280
762c256552e9
WIP: PlaceSprite for lua API. also changed PlaceGirder so that it will return true/false for whether placing was successful too
sheepluva
parents:
10131
diff
changeset

186 
function EnumToStr(const en: TSprite) : shortstring; overload; 
762c256552e9
WIP: PlaceSprite for lua API. also changed PlaceGirder so that it will return true/false for whether placing was successful too
sheepluva
parents:
10131
diff
changeset

187 
begin 
762c256552e9
WIP: PlaceSprite for lua API. also changed PlaceGirder so that it will return true/false for whether placing was successful too
sheepluva
parents:
10131
diff
changeset

188 
EnumToStr := GetEnumName(TypeInfo(TSprite), ord(en)) 
762c256552e9
WIP: PlaceSprite for lua API. also changed PlaceGirder so that it will return true/false for whether placing was successful too
sheepluva
parents:
10131
diff
changeset

189 
end; 
762c256552e9
WIP: PlaceSprite for lua API. also changed PlaceGirder so that it will return true/false for whether placing was successful too
sheepluva
parents:
10131
diff
changeset

190 

10603
bda5c7caf396
switch mapgen to enum. should still try and make sure the values are backwards compatible if possible.
nemo
parents:
10595
diff
changeset

191 
function EnumToStr(const en: TMapGen) : shortstring; overload; 
bda5c7caf396
switch mapgen to enum. should still try and make sure the values are backwards compatible if possible.
nemo
parents:
10595
diff
changeset

192 
begin 
bda5c7caf396
switch mapgen to enum. should still try and make sure the values are backwards compatible if possible.
nemo
parents:
10595
diff
changeset

193 
EnumToStr := GetEnumName(TypeInfo(TMapGen), ord(en)) 
bda5c7caf396
switch mapgen to enum. should still try and make sure the values are backwards compatible if possible.
nemo
parents:
10595
diff
changeset

194 
end; 
bda5c7caf396
switch mapgen to enum. should still try and make sure the values are backwards compatible if possible.
nemo
parents:
10595
diff
changeset

195 

4374  196 

197 
function Min(a, b: LongInt): LongInt; 

198 
begin 

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

199 
if a < b then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6444
diff
changeset

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

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

202 
Min:= b 
4374  203 
end; 
204 

10562  205 
function MinD(a, b: double): double; 
206 
begin 

207 
if a < b then 

208 
MinD:= a 

209 
else 

210 
MinD:= b 

211 
end; 

212 

4374  213 
function Max(a, b: LongInt): LongInt; 
214 
begin 

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

215 
if a > b then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6444
diff
changeset

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

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

218 
Max:= b 
4374  219 
end; 
220 

221 

222 
function IntToStr(n: LongInt): shortstring; 

223 
begin 

224 
str(n, IntToStr) 

225 
end; 

226 

8850
ae8a957c69fd
engine to c now compiles with some manual intervention (as of bug 596)
koda
parents:
8847
diff
changeset

227 
function StrToInt(s: shortstring): LongInt; 
7151  228 
var c: LongInt; 
229 
begin 

8850
ae8a957c69fd
engine to c now compiles with some manual intervention (as of bug 596)
koda
parents:
8847
diff
changeset

230 
{$IFDEF PAS2C} 
ae8a957c69fd
engine to c now compiles with some manual intervention (as of bug 596)
koda
parents:
8847
diff
changeset

231 
val(s, StrToInt); 
ae8a957c69fd
engine to c now compiles with some manual intervention (as of bug 596)
koda
parents:
8847
diff
changeset

232 
{$ELSE} 
8370  233 
val(s, StrToInt, c); 
234 
{$IFDEF DEBUGFILE} 

235 
if c <> 0 then 

10572
c4e86a2efc55
give variable with unitwide scope a better name than just 'f'
sheepluva
parents:
10562
diff
changeset

236 
writeln(logFile, 'Error at position ' + IntToStr(c) + ' : ' + s[c]) 
8370  237 
{$ENDIF} 
8850
ae8a957c69fd
engine to c now compiles with some manual intervention (as of bug 596)
koda
parents:
8847
diff
changeset

238 
{$ENDIF} 
7151  239 
end; 
240 

4374  241 
function FloatToStr(n: hwFloat): shortstring; 
242 
begin 

243 
FloatToStr:= cstr(n) + '_' + inttostr(Lo(n.QWordValue)) 

244 
end; 

245 

246 

9295
f8819c3dde54
Remove some GLunit dependencies noticed on graph. uUtils was using it for GLfloat  but, the stuff it was returning to was usually converting to "real" anyway. uLand was including it unnecessarily. Minor refactor
nemo
parents:
9080
diff
changeset

247 
function DxDy2Angle(const _dY, _dX: hwFloat): real; inline; 
4374  248 
var dY, dX: Extended; 
249 
begin 

7547  250 
dY:= hwFloat2Float(_dY); 
251 
dX:= hwFloat2Float(_dX); 

4374  252 
DxDy2Angle:= arctan2(dY, dX) * 180 / pi 
253 
end; 

254 

255 
function DxDy2Angle32(const _dY, _dX: hwFloat): LongInt; 

256 
const _16divPI: Extended = 16/pi; 

257 
var dY, dX: Extended; 

258 
begin 

7547  259 
dY:= hwFloat2Float(_dY); 
260 
dX:= hwFloat2Float(_dX); 

4374  261 
DxDy2Angle32:= trunc(arctan2(dY, dX) * _16divPI) and $1f 
262 
end; 

263 

264 
function DxDy2AttackAngle(const _dY, _dX: hwFloat): LongInt; 

265 
const MaxAngleDivPI: Extended = cMaxAngle/pi; 

266 
var dY, dX: Extended; 

267 
begin 

7547  268 
dY:= hwFloat2Float(_dY); 
269 
dX:= hwFloat2Float(_dX); 

4374  270 
DxDy2AttackAngle:= trunc(arctan2(dY, dX) * MaxAngleDivPI) 
271 
end; 

272 

6894  273 
function DxDy2AttackAnglef(const _dY, _dX: extended): LongInt; inline; 
5151
cbadb9fa52fc
An experiment  make bazooka AI use float instead of hwFloat  should be as accurate, but faster.
nemo
parents:
5130
diff
changeset

274 
begin 
6894  275 
DxDy2AttackAnglef:= trunc(arctan2(_dY, _dX) * (cMaxAngle/pi)) 
5151
cbadb9fa52fc
An experiment  make bazooka AI use float instead of hwFloat  should be as accurate, but faster.
nemo
parents:
5130
diff
changeset

276 
end; 
cbadb9fa52fc
An experiment  make bazooka AI use float instead of hwFloat  should be as accurate, but faster.
nemo
parents:
5130
diff
changeset

277 

4374  278 

279 
procedure SetLittle(var r: hwFloat); 

280 
begin 

281 
r:= SignAs(cLittle, r) 

282 
end; 

283 

284 

285 
function isPowerOf2(i: Longword): boolean; 

286 
begin 

4981
0c60ade27a0a
Optimize check (not like it is called much, just ffs; not tested)
unc0rr
parents:
4976
diff
changeset

287 
isPowerOf2:= (i and (i  1)) = 0 
4374  288 
end; 
289 

290 
function toPowerOf2(i: Longword): Longword; 

291 
begin 

292 
toPowerOf2:= 1; 

293 
while (toPowerOf2 < i) do toPowerOf2:= toPowerOf2 shl 1 

294 
end; 

295 

296 

297 
function DecodeBase64(s: shortstring): shortstring; 

298 
const table = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'; 

10560  299 
var i, t, c: LongInt; 
4374  300 
begin 
301 
c:= 0; 

302 
for i:= 1 to Length(s) do 

303 
begin 

304 
t:= Pos(s[i], table); 

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

305 
if s[i] = '=' then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6444
diff
changeset

306 
inc(c); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6444
diff
changeset

307 
if t > 0 then 
7074  308 
s[i]:= char(t  1) 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6444
diff
changeset

309 
else 
7074  310 
s[i]:= #0 
4374  311 
end; 
312 

313 
i:= 1; 

314 
t:= 1; 

315 
while i <= length(s) do 

316 
begin 

317 
DecodeBase64[t ]:= char((byte(s[i ]) shl 2) or (byte(s[i + 1]) shr 4)); 

318 
DecodeBase64[t + 1]:= char((byte(s[i + 1]) shl 4) or (byte(s[i + 2]) shr 2)); 

319 
DecodeBase64[t + 2]:= char((byte(s[i + 2]) shl 6) or (byte(s[i + 3]) )); 

320 
inc(t, 3); 

321 
inc(i, 4) 

322 
end; 

323 

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

324 
if c < 3 then 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6444
diff
changeset

325 
t:= t  c; 
4374  326 

7074  327 
DecodeBase64[0]:= char(t  1) 
4374  328 
end; 
329 

330 

331 
function Str2PChar(const s: shortstring): PChar; 

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

332 
var i :Integer ; 
4374  333 
begin 
8026
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7896
diff
changeset

334 
for i:= 1 to Length(s) do 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7896
diff
changeset

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

336 
CharArray[i  1] := s[i]; 
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7896
diff
changeset

337 
end; 
10131
4b4a043111f4
 pas2c recognizes typecasts in initialization expressions
unc0rr
parents:
10127
diff
changeset

338 
CharArray[Length(s)]:= #0; 
8026
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7896
diff
changeset

339 
Str2PChar:= @(CharArray[0]); 
4374  340 
end; 
341 

342 

343 
function endian(independent: LongWord): LongWord; inline; 

344 
begin 

345 
{$IFDEF ENDIAN_LITTLE} 

346 
endian:= independent; 

347 
{$ELSE} 

348 
endian:= (((independent and $FF000000) shr 24) or 

349 
((independent and $00FF0000) shr 8) or 

350 
((independent and $0000FF00) shl 8) or 

351 
((independent and $000000FF) shl 24)) 

352 
{$ENDIF} 

353 
end; 

354 

355 

356 
procedure AddFileLog(s: shortstring); 

357 
begin 

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

358 
// s:= s; 
4900  359 
{$IFDEF DEBUGFILE} 
8026
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7896
diff
changeset

360 

7198
5debd5fe526e
1. Add IFDEFs for video recording
Stepan777 <stepik777@mail.ru>
parents:
7194
diff
changeset

361 
{$IFDEF USE_VIDEO_RECORDING} 
7180  362 
EnterCriticalSection(logMutex); 
7198
5debd5fe526e
1. Add IFDEFs for video recording
Stepan777 <stepik777@mail.ru>
parents:
7194
diff
changeset

363 
{$ENDIF} 
10572
c4e86a2efc55
give variable with unitwide scope a better name than just 'f'
sheepluva
parents:
10562
diff
changeset

364 
writeln(logFile, inttostr(GameTicks) + ': ' + s); 
c4e86a2efc55
give variable with unitwide scope a better name than just 'f'
sheepluva
parents:
10562
diff
changeset

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

366 

7198
5debd5fe526e
1. Add IFDEFs for video recording
Stepan777 <stepik777@mail.ru>
parents:
7194
diff
changeset

367 
{$IFDEF USE_VIDEO_RECORDING} 
7180  368 
LeaveCriticalSection(logMutex); 
4900  369 
{$ENDIF} 
8026
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7896
diff
changeset

370 

7198
5debd5fe526e
1. Add IFDEFs for video recording
Stepan777 <stepik777@mail.ru>
parents:
7194
diff
changeset

371 
{$ENDIF} 
4374  372 
end; 
373 

7180  374 
procedure AddFileLogRaw(s: pchar); cdecl; 
375 
begin 

376 
s:= s; 

9966  377 
{$IFNDEF PAS2C} 
7180  378 
{$IFDEF DEBUGFILE} 
7198
5debd5fe526e
1. Add IFDEFs for video recording
Stepan777 <stepik777@mail.ru>
parents:
7194
diff
changeset

379 
{$IFDEF USE_VIDEO_RECORDING} 
7180  380 
EnterCriticalSection(logMutex); 
7198
5debd5fe526e
1. Add IFDEFs for video recording
Stepan777 <stepik777@mail.ru>
parents:
7194
diff
changeset

381 
{$ENDIF} 
10572
c4e86a2efc55
give variable with unitwide scope a better name than just 'f'
sheepluva
parents:
10562
diff
changeset

382 
write(logFile, s); 
c4e86a2efc55
give variable with unitwide scope a better name than just 'f'
sheepluva
parents:
10562
diff
changeset

383 
flush(logFile); 
7198
5debd5fe526e
1. Add IFDEFs for video recording
Stepan777 <stepik777@mail.ru>
parents:
7194
diff
changeset

384 
{$IFDEF USE_VIDEO_RECORDING} 
7180  385 
LeaveCriticalSection(logMutex); 
386 
{$ENDIF} 

7198
5debd5fe526e
1. Add IFDEFs for video recording
Stepan777 <stepik777@mail.ru>
parents:
7194
diff
changeset

387 
{$ENDIF} 
9966  388 
{$ENDIF} 
7180  389 
end; 
4374  390 

10116
dd27562b6f21
rolling back my PChar stuff, because unC0Rr improves string handling pas2c instead <3
sheepluva
parents:
10108
diff
changeset

391 
function CheckCJKFont(s: ansistring; font: THWFont): THWFont; 
4380  392 
var l, i : LongInt; 
393 
u: WideChar; 

394 
tmpstr: array[0..256] of WideChar; 

395 
begin 

6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6978
diff
changeset

396 
CheckCJKFont:= font; 
4380  397 

5639  398 
{$IFNDEF MOBILE} 
4380  399 
// remove chinese fonts for now 
10116
dd27562b6f21
rolling back my PChar stuff, because unC0Rr improves string handling pas2c instead <3
sheepluva
parents:
10108
diff
changeset

400 
if (font >= CJKfnt16) or (length(s) = 0) then 
4380  401 
{$ENDIF} 
6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6978
diff
changeset

402 
exit; 
4380  403 

10131
4b4a043111f4
 pas2c recognizes typecasts in initialization expressions
unc0rr
parents:
10127
diff
changeset

404 
l:= Utf8ToUnicode(PWideChar(@tmpstr), PChar(s), min(length(tmpstr), length(s)))1; 
4380  405 
i:= 0; 
4737  406 

4380  407 
while i < l do 
408 
begin 

409 
u:= tmpstr[i]; 

4737  410 
if (#$1100 <= u) and ( 
411 
(u <= #$11FF ) or // Hangul Jamo 

412 
((#$2E80 <= u) and (u <= #$2FDF)) or // CJK Radicals Supplement / Kangxi Radicals 

8575  413 
((#$2FF0 <= u) and (u <= #$31FF)) or // Ideographic Description Characters / CJK Radicals Supplement / Hiragana / Hangul Compatibility Jamo / Katakana 
4380  414 
((#$31C0 <= u) and (u <= #$31EF)) or // CJK Strokes 
8575  415 
((#$3200 <= u) and (u <= #$4DBF)) or // Enclosed CJK Letters and Months / CJK Compatibility / CJK Unified Ideographs Extension A / Circled Katakana 
4380  416 
((#$4E00 <= u) and (u <= #$9FFF)) or // CJK Unified Ideographs 
4737  417 
((#$AC00 <= u) and (u <= #$D7AF)) or // Hangul Syllables 
4380  418 
((#$F900 <= u) and (u <= #$FAFF)) or // CJK Compatibility Ideographs 
8575  419 
((#$FE30 <= u) and (u <= #$FE4F)) or // CJK Compatibility Forms 
420 
((#$FF66 <= u) and (u <= #$FF9D))) // halfwidth katakana 

10015  421 
then 
6990
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6978
diff
changeset

422 
begin 
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6978
diff
changeset

423 
CheckCJKFont:= THWFont( ord(font) + ((ord(High(THWFont))+1) div 2) ); 
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6978
diff
changeset

424 
exit; 
40e5af28d026
change every return value into a more pascalish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6978
diff
changeset

425 
end; 
4380  426 
inc(i) 
427 
end; 

428 
(* two more to check. pascal WideChar is only 16 bit though 

429 
((#$20000 <= u) and (u >= #$2A6DF)) or // CJK Unified Ideographs Extension B 

430 
((#$2F800 <= u) and (u >= #$2FA1F))) // CJK Compatibility Ideographs Supplement *) 

431 
end; 

432 

4385  433 

434 
function GetLaunchX(at: TAmmoType; dir: LongInt; angle: LongInt): LongInt; 

435 
begin 

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

436 
GetLaunchX:= 0 
4665
fa7ad5f3725f
Make basic training solvable again. Freeze RNG at current version for less of this kind of issue in future, and a bit more savable of seeds. Disable offsets in preparation for release.
nemo
parents:
4453
diff
changeset

437 
(* 
4385  438 
if (Ammoz[at].ejectX <> 0) or (Ammoz[at].ejectY <> 0) then 
439 
GetLaunchX:= sign(dir) * (8 + hwRound(AngleSin(angle) * Ammoz[at].ejectX) + hwRound(AngleCos(angle) * Ammoz[at].ejectY)) 

440 
else 

4665
fa7ad5f3725f
Make basic training solvable again. Freeze RNG at current version for less of this kind of issue in future, and a bit more savable of seeds. Disable offsets in preparation for release.
nemo
parents:
4453
diff
changeset

441 
GetLaunchX:= 0 *) 
4385  442 
end; 
443 

444 
function GetLaunchY(at: TAmmoType; angle: LongInt): LongInt; 

445 
begin 

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

446 
GetLaunchY:= 0 
4665
fa7ad5f3725f
Make basic training solvable again. Freeze RNG at current version for less of this kind of issue in future, and a bit more savable of seeds. Disable offsets in preparation for release.
nemo
parents:
4453
diff
changeset

447 
(* 
4385  448 
if (Ammoz[at].ejectX <> 0) or (Ammoz[at].ejectY <> 0) then 
449 
GetLaunchY:= hwRound(AngleSin(angle) * Ammoz[at].ejectY)  hwRound(AngleCos(angle) * Ammoz[at].ejectX)  2 

450 
else 

4665
fa7ad5f3725f
Make basic training solvable again. Freeze RNG at current version for less of this kind of issue in future, and a bit more savable of seeds. Disable offsets in preparation for release.
nemo
parents:
4453
diff
changeset

451 
GetLaunchY:= 0*) 
4385  452 
end; 
453 

4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4385
diff
changeset

454 
function CheckNoTeamOrHH: boolean; 
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4385
diff
changeset

455 
begin 
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4385
diff
changeset

456 
CheckNoTeamOrHH:= (CurrentTeam = nil) or (CurrentHedgehog^.Gear = nil); 
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4385
diff
changeset

457 
end; 
4385  458 

7151  459 
{$IFNDEF PAS2C} 
460 
procedure Write(var f: textfile; s: shortstring); 

461 
begin 

462 
system.write(f, s) 

463 
end; 

464 

465 
procedure WriteLn(var f: textfile; s: shortstring); 

466 
begin 

467 
system.writeln(f, s) 

468 
end; 

10080  469 

470 
function StrLength(s: PChar): Longword; 

471 
begin 

472 
StrLength:= length(s) 

473 
end; 

7151  474 
{$ENDIF} 
475 

8204  476 
// this function is just to determine whether we are running on a limited screen device 
477 
function isPhone: Boolean; inline; 

478 
begin 

479 
isPhone:= false; 

480 
{$IFDEF IPHONEOS} 

481 
isPhone:= isApplePhone(); 

482 
{$ENDIF} 

483 
{$IFDEF ANDROID} 

484 
//nasty nasty hack. TODO: implement callback to java to have a unified way of determining if it is a tablet 

485 
if (cScreenWidth < 1000) and (cScreenHeight < 500) then 

486 
isPhone:= true; 

487 
{$ENDIF} 

488 
end; 

489 

490 

8498
eecadca7db50
Bring back full log strings for commands, just a bit sanitized
unc0rr
parents:
8425
diff
changeset

491 
function sanitizeForLog(s: shortstring): shortstring; 
eecadca7db50
Bring back full log strings for commands, just a bit sanitized
unc0rr
parents:
8425
diff
changeset

492 
var i: byte; 
eecadca7db50
Bring back full log strings for commands, just a bit sanitized
unc0rr
parents:
8425
diff
changeset

493 
r: shortstring; 
eecadca7db50
Bring back full log strings for commands, just a bit sanitized
unc0rr
parents:
8425
diff
changeset

494 
begin 
eecadca7db50
Bring back full log strings for commands, just a bit sanitized
unc0rr
parents:
8425
diff
changeset

495 
r[0]:= s[0]; 
eecadca7db50
Bring back full log strings for commands, just a bit sanitized
unc0rr
parents:
8425
diff
changeset

496 
for i:= 1 to length(s) do 
eecadca7db50
Bring back full log strings for commands, just a bit sanitized
unc0rr
parents:
8425
diff
changeset

497 
if (s[i] < #32) or (s[i] > #127) then 
eecadca7db50
Bring back full log strings for commands, just a bit sanitized
unc0rr
parents:
8425
diff
changeset

498 
r[i]:= '?' 
eecadca7db50
Bring back full log strings for commands, just a bit sanitized
unc0rr
parents:
8425
diff
changeset

499 
else 
eecadca7db50
Bring back full log strings for commands, just a bit sanitized
unc0rr
parents:
8425
diff
changeset

500 
r[i]:= s[i]; 
10015  501 

8498
eecadca7db50
Bring back full log strings for commands, just a bit sanitized
unc0rr
parents:
8425
diff
changeset

502 
sanitizeForLog:= r 
eecadca7db50
Bring back full log strings for commands, just a bit sanitized
unc0rr
parents:
8425
diff
changeset

503 
end; 
eecadca7db50
Bring back full log strings for commands, just a bit sanitized
unc0rr
parents:
8425
diff
changeset

504 

eecadca7db50
Bring back full log strings for commands, just a bit sanitized
unc0rr
parents:
8425
diff
changeset

505 
function sanitizeCharForLog(c: char): shortstring; 
eecadca7db50
Bring back full log strings for commands, just a bit sanitized
unc0rr
parents:
8425
diff
changeset

506 
var r: shortstring; 
eecadca7db50
Bring back full log strings for commands, just a bit sanitized
unc0rr
parents:
8425
diff
changeset

507 
begin 
eecadca7db50
Bring back full log strings for commands, just a bit sanitized
unc0rr
parents:
8425
diff
changeset

508 
if (c < #32) or (c > #127) then 
eecadca7db50
Bring back full log strings for commands, just a bit sanitized
unc0rr
parents:
8425
diff
changeset

509 
r:= '#' + inttostr(byte(c)) 
eecadca7db50
Bring back full log strings for commands, just a bit sanitized
unc0rr
parents:
8425
diff
changeset

510 
else 
8841  511 
begin 
512 
// some magic for pas2c 

513 
r[0]:= #1; 

514 
r[1]:= c; 

515 
end; 

516 

8498
eecadca7db50
Bring back full log strings for commands, just a bit sanitized
unc0rr
parents:
8425
diff
changeset

517 
sanitizeCharForLog:= r 
eecadca7db50
Bring back full log strings for commands, just a bit sanitized
unc0rr
parents:
8425
diff
changeset

518 
end; 
eecadca7db50
Bring back full log strings for commands, just a bit sanitized
unc0rr
parents:
8425
diff
changeset

519 

7896
67217e6108fd
another stake at variable preinitialisation  we lost preview logging in the course
koda
parents:
7565
diff
changeset

520 
procedure initModule(isNotPreview: boolean); 
7027  521 
{$IFDEF DEBUGFILE} 
522 
var logfileBase: shortstring; 

8095  523 
i: LongInt; 
10595
6781190b053d
turns out IOResult is actually IOResult()  a function that clears its result after each call
sheepluva
parents:
10594
diff
changeset

524 
rwfailed: boolean; 
7027  525 
{$ENDIF} 
4374  526 
begin 
527 
{$IFDEF DEBUGFILE} 

7896
67217e6108fd
another stake at variable preinitialisation  we lost preview logging in the course
koda
parents:
7565
diff
changeset

528 
if isNotPreview then 
7386
e82a076df09b
Fix bug with isInLag picture displayed at end of some videos.
Stepan777 <stepik777@mail.ru>
parents:
7198
diff
changeset

529 
begin 
e82a076df09b
Fix bug with isInLag picture displayed at end of some videos.
Stepan777 <stepik777@mail.ru>
parents:
7198
diff
changeset

530 
if GameType = gmtRecord then 
e82a076df09b
Fix bug with isInLag picture displayed at end of some videos.
Stepan777 <stepik777@mail.ru>
parents:
7198
diff
changeset

531 
logfileBase:= 'rec' 
e82a076df09b
Fix bug with isInLag picture displayed at end of some videos.
Stepan777 <stepik777@mail.ru>
parents:
7198
diff
changeset

532 
else 
10505  533 
{$IFDEF PAS2C} 
534 
logfileBase:= 'game_pas2c'; 

535 
{$ELSE} 

536 
logfileBase:= 'game'; 

537 
{$ENDIF} 

7386
e82a076df09b
Fix bug with isInLag picture displayed at end of some videos.
Stepan777 <stepik777@mail.ru>
parents:
7198
diff
changeset

538 
end 
7027  539 
else 
10502
a888e649bea2
Fix difference in map generation between fpc and pas2c engine
unc0rr
parents:
10280
diff
changeset

540 
{$IFDEF PAS2C} 
10503  541 
logfileBase:= 'preview_pas2c'; 
10502
a888e649bea2
Fix difference in map generation between fpc and pas2c engine
unc0rr
parents:
10280
diff
changeset

542 
{$ELSE} 
10504  543 
logfileBase:= 'preview'; 
10502
a888e649bea2
Fix difference in map generation between fpc and pas2c engine
unc0rr
parents:
10280
diff
changeset

544 
{$ENDIF} 
7198
5debd5fe526e
1. Add IFDEFs for video recording
Stepan777 <stepik777@mail.ru>
parents:
7194
diff
changeset

545 
{$IFDEF USE_VIDEO_RECORDING} 
7180  546 
InitCriticalSection(logMutex); 
7198
5debd5fe526e
1. Add IFDEFs for video recording
Stepan777 <stepik777@mail.ru>
parents:
7194
diff
changeset

547 
{$ENDIF} 
4374  548 
{$I} 
10595
6781190b053d
turns out IOResult is actually IOResult()  a function that clears its result after each call
sheepluva
parents:
10594
diff
changeset

549 
rwfailed:= false; 
10127  550 
if (length(UserPathPrefix) > 0) then 
4374  551 
begin 
9966  552 
{$IFNDEF PAS2C} 
8425
4f226963faef
restored ios project file, updated Game() interface, tweaked arg parsing, updated log writing, minor warnings
koda
parents:
8370
diff
changeset

553 
// create directory if it doesn't exist 
8095  554 
if not FileExists(UserPathPrefix + '/Logs/') then 
555 
CreateDir(UserPathPrefix + '/Logs/'); 

9966  556 
{$ENDIF} 
8425
4f226963faef
restored ios project file, updated Game() interface, tweaked arg parsing, updated log writing, minor warnings
koda
parents:
8370
diff
changeset

557 
// if log is locked, write to the next one 
8095  558 
i:= 0; 
559 
while(i < 7) do 

4374  560 
begin 
10572
c4e86a2efc55
give variable with unitwide scope a better name than just 'f'
sheepluva
parents:
10562
diff
changeset

561 
assign(logFile, shortstring(UserPathPrefix) + '/Logs/' + logfileBase + inttostr(i) + '.log'); 
10573
3b82b4d90eb7
make the code, which was supposed to iterate file log number (if no access) and fallback to stderr in worst case rather than segfault, actually work
sheepluva
parents:
10572
diff
changeset

562 
Rewrite(logFile); 
10605
df7a73db2c43
oops, IOResult is a function in pascal, but not in pas2c
sheepluva
parents:
10603
diff
changeset

563 
// note: IOResult is a function in pascal and a variable in pas2c 
df7a73db2c43
oops, IOResult is a function in pascal, but not in pas2c
sheepluva
parents:
10603
diff
changeset

564 
rwfailed:= (IOResult <> 0); 
10595
6781190b053d
turns out IOResult is actually IOResult()  a function that clears its result after each call
sheepluva
parents:
10594
diff
changeset

565 
if (not rwfailed) then 
8095  566 
break; 
567 
inc(i) 

4374  568 
end; 
8095  569 
end; 
10573
3b82b4d90eb7
make the code, which was supposed to iterate file log number (if no access) and fallback to stderr in worst case rather than segfault, actually work
sheepluva
parents:
10572
diff
changeset

570 

3b82b4d90eb7
make the code, which was supposed to iterate file log number (if no access) and fallback to stderr in worst case rather than segfault, actually work
sheepluva
parents:
10572
diff
changeset

571 
{$IFNDEF PAS2C} 
10574  572 
// if everything fails, write to stderr 
10595
6781190b053d
turns out IOResult is actually IOResult()  a function that clears its result after each call
sheepluva
parents:
10594
diff
changeset

573 
if (length(UserPathPrefix) = 0) or (rwfailed) then 
10574  574 
logFile:= stderr; 
10573
3b82b4d90eb7
make the code, which was supposed to iterate file log number (if no access) and fallback to stderr in worst case rather than segfault, actually work
sheepluva
parents:
10572
diff
changeset

575 
{$ENDIF} 
4374  576 
{$I+} 
577 
{$ENDIF} 

578 

9300  579 
//mobile stuff 
580 
{$IFDEF IPHONEOS} 

581 
mobileRecord.PerformRumble:= @AudioServicesPlaySystemSound; 

582 
mobileRecord.GameLoading:= @startLoadingIndicator; 

583 
mobileRecord.GameLoaded:= @stopLoadingIndicator; 

584 
mobileRecord.SaveLoadingEnded:= @saveFinishedSynching; 

585 
{$ELSE} 

586 
mobileRecord.PerformRumble:= nil; 

587 
mobileRecord.GameLoading:= nil; 

588 
mobileRecord.GameLoaded:= nil; 

589 
mobileRecord.SaveLoadingEnded:= nil; 

590 
{$ENDIF} 

591 

4374  592 
end; 
593 

594 
procedure freeModule; 

595 
begin 

596 
{$IFDEF DEBUGFILE} 

10572
c4e86a2efc55
give variable with unitwide scope a better name than just 'f'
sheepluva
parents:
10562
diff
changeset

597 
writeln(logFile, 'halt at ' + inttostr(GameTicks) + ' ticks. TurnTimeLeft = ' + inttostr(TurnTimeLeft)); 
c4e86a2efc55
give variable with unitwide scope a better name than just 'f'
sheepluva
parents:
10562
diff
changeset

598 
flush(logFile); 
c4e86a2efc55
give variable with unitwide scope a better name than just 'f'
sheepluva
parents:
10562
diff
changeset

599 
close(logFile); 
7198
5debd5fe526e
1. Add IFDEFs for video recording
Stepan777 <stepik777@mail.ru>
parents:
7194
diff
changeset

600 
{$IFDEF USE_VIDEO_RECORDING} 
7180  601 
DoneCriticalSection(logMutex); 
4374  602 
{$ENDIF} 
7198
5debd5fe526e
1. Add IFDEFs for video recording
Stepan777 <stepik777@mail.ru>
parents:
7194
diff
changeset

603 
{$ENDIF} 
4374  604 
end; 
605 

4453  606 
end. 