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

   166 procedure SplitByChar(var a, b: ansistring; c: char);

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

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

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

   170 function  EnumToStr(const en : THogEffect) : shortstring; overload;

   171 procedure movecursor(dx, dy: LongInt);

   172 function  hwSign(r: hwFloat): LongInt; inline;

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

   174 function  Max(a, b: LongInt): LongInt; inline;

   175 procedure OutError(Msg: shortstring; isFatalError: boolean);

   176 procedure TryDo(Assert: boolean; Msg: shortstring; isFatal: boolean); inline;

   177 procedure SDLTry(Assert: boolean; isFatal: boolean);

   178 function  IntToStr(n: LongInt): shortstring;

   179 function  FloatToStr(n: hwFloat): shortstring;

   180 function  DxDy2Angle(const _dY, _dX: hwFloat): GLfloat;

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

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

   183 (*

   184 procedure AdjustColor(var Color: Longword);

   185 procedure SetKB(n: Longword);

   186 *)

   187 procedure SendKB;

   188 procedure SetLittle(var r: hwFloat);

   189 procedure SendStat(sit: TStatInfoType; s: shortstring);

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

   191 function  NewTexture(width, height: Longword; buf: Pointer): PTexture;

   192 function  Surface2Tex(surf: PSDL_Surface; enableClamp: boolean): PTexture;

   193 procedure FreeTexture(tex: PTexture);

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

   195 function  DecodeBase64(s: shortstring): shortstring;

   196 function  doSurfaceConversion(tmpsurf: PSDL_Surface): PSDL_Surface;

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

   198 {$IFDEF DEBUGFILE}

   199 procedure AddFileLog(s: shortstring);

   200 (* function  RectToStr(Rect: TSDL_Rect): shortstring; *)

   201 {$ENDIF}

   202 procedure MakeScreenshot(filename: shortstring);

   268 function hwSign(r: hwFloat): LongInt;

   269 begin

   270 // yes, we have negative zero for a reason

   271 if r.isNegative then hwSign:= -1 else hwSign:= 1

   272 end;

   273 

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

   275 begin

   276 if a < b then Min:= a else Min:= b

   277 end;

   278 

   279 function Max(a, b: LongInt): LongInt;

   280 begin

   281 if a > b then Max:= a else Max:= b

   282 end;

   283 

   284 procedure OutError(Msg: shortstring; isFatalError: boolean);

   285 begin

   286 // obsolete? written in WriteLnToConsole() anyway

   287 // {$IFDEF DEBUGFILE}AddFileLog(Msg);{$ENDIF}

   288 WriteLnToConsole(Msg);

   289 if isFatalError then

   290     begin

   291     SendIPC('E' + GetLastConsoleLine);

   292     SDL_Quit;

   293     halt(1)

   294     end

   295 end;

   296 

   297 procedure TryDo(Assert: boolean; Msg: shortstring; isFatal: boolean);

   298 begin

   299 if not Assert then OutError(Msg, isFatal)

   300 end;

   301 

   302 procedure SDLTry(Assert: boolean; isFatal: boolean);

   303 begin

   304 if not Assert then OutError(SDL_GetError, isFatal)

   305 end;

   306 

   307 (*

   308 procedure AdjustColor(var Color: Longword);

   309 begin

   310 Color:= SDL_MapRGB(PixelFormat, (Color shr 16) and $FF, (Color shr 8) and $FF, Color and $FF)

   311 end;

   312 

   313 procedure SetKB(n: Longword);

   314 begin

   315 KBnum:= n

   316 end;

   317 *)

   318 

   319 

   320 function IntToStr(n: LongInt): shortstring;

   321 begin

   322 str(n, IntToStr)

   323 end;

   324 

   325 function FloatToStr(n: hwFloat): shortstring;

   326 begin

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

   328 end;

   329 

   330 procedure SetTextureParameters(enableClamp: Boolean);

   331 begin

   332     if enableClamp and ((cReducedQuality and rqClampLess) = 0) then

   333     begin

   334         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

   335         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)

   336     end;

   337     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

   338     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)

   339 end;

   340 

   341 function DxDy2Angle(const _dY, _dX: hwFloat): GLfloat;

   342 var dY, dX: Extended;

   343 begin

   344 dY:= _dY.QWordValue / $100000000;

   345 if _dY.isNegative then dY:= - dY;

   346 dX:= _dX.QWordValue / $100000000;

   347 if _dX.isNegative then dX:= - dX;

   348 DxDy2Angle:= arctan2(dY, dX) * 180 / pi

   349 end;

   350 

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

   352 const _16divPI: Extended = 16/pi;

   353 var dY, dX: Extended;

   354 begin

   355 dY:= _dY.QWordValue / $100000000;

   356 if _dY.isNegative then dY:= - dY;

   357 dX:= _dX.QWordValue / $100000000;

   358 if _dX.isNegative then dX:= - dX;

   359 DxDy2Angle32:= trunc(arctan2(dY, dX) * _16divPI) and $1f

   360 end;

   361 

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

   363 const MaxAngleDivPI: Extended = cMaxAngle/pi;

   364 var dY, dX: Extended;

   365 begin

   366 dY:= _dY.QWordValue / $100000000;

   367 if _dY.isNegative then dY:= - dY;

   368 dX:= _dX.QWordValue / $100000000;

   369 if _dX.isNegative then dX:= - dX;

   370 DxDy2AttackAngle:= trunc(arctan2(dY, dX) * MaxAngleDivPI)

   371 end;

   372 

   373 procedure SendKB;

   374 var s: shortstring;

   375 begin

   376 if KBnum <> 0 then

   377 begin

   378 s:= 'K' + inttostr(KBnum);

   379 SendIPCRaw(@s, Length(s) + 1)

   380 end

   381 end;

   382 

   383 procedure SetLittle(var r: hwFloat);

   384 begin

   385 r:= SignAs(cLittle, r)

   386 end;

   387 

   388 procedure SendStat(sit: TStatInfoType; s: shortstring);

   389 const stc: array [TStatInfoType] of char = 'rDkKHTPsSB';

   390 var buf: shortstring;

   391 begin

   392 buf:= 'i' + stc[sit] + s;

   393 SendIPCRaw(@buf[0], length(buf) + 1)

   394 end;

   395 

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

   397 const CharArray: array[byte] of Char = '';

   398 begin

   399 CharArray:= s;

   400 CharArray[Length(s)]:= #0;

   401 Str2PChar:= @CharArray

   402 end;

   403 

   404 function isPowerOf2(i: Longword): boolean;

   405 begin

   406 if i = 0 then exit(true);

   407 while (i and 1) = 0 do i:= i shr 1;

   408 isPowerOf2:= (i = 1)

   409 end;

   410 

   411 function toPowerOf2(i: Longword): Longword;

   412 begin

   413 toPowerOf2:= 1;

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

   415 end;

   416 

   417 procedure ResetVertexArrays(texture: PTexture);

   418 begin

   419 with texture^ do

   420     begin

   421     vb[0].X:= 0;

   422     vb[0].Y:= 0;

   423     vb[1].X:= w;

   424     vb[1].Y:= 0;

   425     vb[2].X:= w;

   426     vb[2].Y:= h;

   427     vb[3].X:= 0;

   428     vb[3].Y:= h;

   429 

   430     tb[0].X:= 0;

   431     tb[0].Y:= 0;

   432     tb[1].X:= rx;

   433     tb[1].Y:= 0;

   434     tb[2].X:= rx;

   435     tb[2].Y:= ry;

   436     tb[3].X:= 0;

   437     tb[3].Y:= ry

   438     end;

   439 end;

   440 

   441 function NewTexture(width, height: Longword; buf: Pointer): PTexture;

   442 begin

   443 new(NewTexture);

   444 NewTexture^.PrevTexture:= nil;

   445 NewTexture^.NextTexture:= nil;

   446 NewTexture^.Scale:= 1;

   447 if TextureList <> nil then

   448     begin

   449     TextureList^.PrevTexture:= NewTexture;

   450     NewTexture^.NextTexture:= TextureList

   451     end;

   452 TextureList:= NewTexture;

   453 

   454 NewTexture^.w:= width;

   455 NewTexture^.h:= height;

   456 NewTexture^.rx:= 1.0;

   457 NewTexture^.ry:= 1.0;

   458 

   459 ResetVertexArrays(NewTexture);

   460 

   461 glGenTextures(1, @NewTexture^.id);

   462 

   463 glBindTexture(GL_TEXTURE_2D, NewTexture^.id);

   464 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, buf);

   465 

   466 SetTextureParameters(true);

   467 end;

   468 

   469 function Surface2Tex(surf: PSDL_Surface; enableClamp: boolean): PTexture;

   470 var tw, th, x, y: Longword;

   471     tmpp: pointer;

   472     fromP4, toP4: PLongWordArray;

   473 begin

   474 new(Surface2Tex);

   475 Surface2Tex^.PrevTexture:= nil;

   476 Surface2Tex^.NextTexture:= nil;

   477 if TextureList <> nil then

   478     begin

   479     TextureList^.PrevTexture:= Surface2Tex;

   480     Surface2Tex^.NextTexture:= TextureList

   481     end;

   482 TextureList:= Surface2Tex;

   483 

   484 Surface2Tex^.w:= surf^.w;

   485 Surface2Tex^.h:= surf^.h;

   486 

   487 if (surf^.format^.BytesPerPixel <> 4) then

   488     begin

   489     TryDo(false, 'Surface2Tex failed, expecting 32 bit surface', true);

   490     Surface2Tex^.id:= 0;

   491     exit

   492     end;

   493 

   494 

   495 glGenTextures(1, @Surface2Tex^.id);

   496 

   497 glBindTexture(GL_TEXTURE_2D, Surface2Tex^.id);

   498 

   499 if SDL_MustLock(surf) then

   500     SDLTry(SDL_LockSurface(surf) >= 0, true);

   501 

   502 if (not SupportNPOTT) and (not (isPowerOf2(Surf^.w) and isPowerOf2(Surf^.h))) then

   503     begin

   504     tw:= toPowerOf2(Surf^.w);

   505     th:= toPowerOf2(Surf^.h);

   506 

   507     Surface2Tex^.rx:= Surf^.w / tw;

   508     Surface2Tex^.ry:= Surf^.h / th;

   509 

   510     GetMem(tmpp, tw * th * surf^.format^.BytesPerPixel);

   511 

   512     fromP4:= Surf^.pixels;

   513     toP4:= tmpp;

   514 

   515     for y:= 0 to Pred(Surf^.h) do

   516         begin

   517         for x:= 0 to Pred(Surf^.w) do toP4^[x]:= fromP4^[x];

   518         for x:= Surf^.w to Pred(tw) do toP4^[x]:= 0;

   519         toP4:= @(toP4^[tw]);

   520         fromP4:= @(fromP4^[Surf^.pitch div 4])

   521         end;

   522 

   523     for y:= Surf^.h to Pred(th) do

   524         begin

   525         for x:= 0 to Pred(tw) do toP4^[x]:= 0;

   526         toP4:= @(toP4^[tw])

   527         end;

   528 

   529     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tw, th, 0, GL_RGBA, GL_UNSIGNED_BYTE, tmpp);

   530 

   531     FreeMem(tmpp, tw * th * surf^.format^.BytesPerPixel)

   532     end

   533 else

   534     begin

   535     Surface2Tex^.rx:= 1.0;

   536     Surface2Tex^.ry:= 1.0;

   537     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, surf^.w, surf^.h, 0, GL_RGBA, GL_UNSIGNED_BYTE, surf^.pixels);

   538     end;

   539 

   540 ResetVertexArrays(Surface2Tex);

   541 

   542 if SDL_MustLock(surf) then

   543     SDL_UnlockSurface(surf);

   544 

   545 SetTextureParameters(enableClamp);

   546 end;

   547 

   548 procedure FreeTexture(tex: PTexture);

   549 begin

   550     if tex <> nil then

   551     begin

   552         if tex^.NextTexture <> nil then

   553             tex^.NextTexture^.PrevTexture:= tex^.PrevTexture;

   554         if tex^.PrevTexture <> nil then

   555             tex^.PrevTexture^.NextTexture:= tex^.NextTexture

   556         else

   557             TextureList:= tex^.NextTexture;

   558         glDeleteTextures(1, @tex^.id);

   559         Dispose(tex);

   560     end

   561 end;

   562 

   563 function DecodeBase64(s: shortstring): shortstring;

   564 const table = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';

   565 var i, t, c: Longword;

   566 begin

   567 c:= 0;

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

   569     begin

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

   571     if s[i] = '=' then inc(c);

   572     if t > 0 then byte(s[i]):= t - 1 else byte(s[i]):= 0

   573     end;

   574 

   575 i:= 1;

   576 t:= 1;

   577 while i <= length(s) do

   578     begin

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

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

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

   582     inc(t, 3);

   583     inc(i, 4)

   584     end;

   585 

   586 if c < 3 then t:= t - c;

   587 

   588 byte(DecodeBase64[0]):= t - 1

   589 end;

   614 playSound(sndShutter);

   615 

   663 {$IFDEF DEBUGFILE}

   664 procedure AddFileLog(s: shortstring);

   665 begin

   666 writeln(f, GameTicks: 6, ': ', s);

   667 flush(f)

   668 end;

   669 (*

   670 function RectToStr(Rect: TSDL_Rect): shortstring;

   671 begin

   672 RectToStr:= '(x: ' + inttostr(rect.x) + '; y: ' + inttostr(rect.y) + '; w: ' + inttostr(rect.w) + '; h: ' + inttostr(rect.h) + ')'

   673 end;

   674 *)

   675 {$ENDIF}

   676 

   703 

   705 {$IFDEF DEBUGFILE}{$IFNDEF IPHONEOS}var i: LongInt;{$ENDIF}{$ENDIF}

   707     Pathz:= cPathz;

   708         {*  REFERENCE

   709       4096 -> $FFFFF000

   710       2048 -> $FFFFF800

   711       1024 -> $FFFFFC00

   712        512 -> $FFFFFE00  *}

   713     if (cReducedQuality and rqLowRes) <> 0 then

   714     begin

   715         LAND_WIDTH:= 2048;

   716         LAND_HEIGHT:= 1024;

   717         LAND_WIDTH_MASK:= $FFFFF800;

   718         LAND_HEIGHT_MASK:= $FFFFFC00;

   719     end

   720     else

   721     begin

   722         LAND_WIDTH:= 4096;

   723         LAND_HEIGHT:= 2048;

   724         LAND_WIDTH_MASK:= $FFFFF000;

   725         LAND_HEIGHT_MASK:= $FFFFF800

   726     end;

   727 

   728     cDrownSpeed.QWordValue  := 257698038;       // 0.06

   729     cDrownSpeedf            := 0.06;

   730     cMaxWindSpeed.QWordValue:= 1073742;     // 0.00025

   731     cWindSpeed.QWordValue   := 429496;      // 0.0001

   732     cWindSpeedf             := 0.0001;

   733     cGravity                := cMaxWindSpeed * 2;

   734     cGravityf               := 0.00025 * 2;

   735     cDamageModifier         := _1;

   736     TargetPoint             := cTargetPointRef;

   737     TextureList             := nil;

   738 

   739     // int, longint longword and byte

   740     CursorMovementX     := 0;

   741     CursorMovementY     := 0;

   742     GameTicks           := 0;

   743     TrainingTimeInc     := 10000;

   744     TrainingTimeInD     := 500;

   745     TrainingTimeInM     := 5000;

   746     TrainingTimeMax     := 60000;

   747     TimeTrialStartTime  := 0;

   748     TimeTrialStopTime   := 0;

   749     cWaterLine          := LAND_HEIGHT;

   750     cGearScrEdgesDist   := 240;

   751 

   752     GameFlags           := 0;

   753     TrainingFlags       := 0;

   754     TurnTimeLeft        := 0;

   755     cSuddenDTurns       := 15;

   756     cDamagePercent      := 100;

   757     cMineDudPercent     := 0;

   758     cTemplateFilter     := 0;

   759     cMapGen             := 0;   // MAPGEN_REGULAR

   760     cMazeSize           := 0;

   761     cHedgehogTurnTime   := 45000;

   762     cMinesTime          := 3;

   763     cMaxAIThinkTime     := 9000;

   764     cCloudsNumber       := 9;

   765     cHealthCaseProb     := 35;

   766     cHealthCaseAmount   := 25;

   767     cWaterRise          := 47;

   768     cHealthDecrease     := 5;

   769 

   770     cTagsMask       := 0;

   771     KBnum           := 0;

   772     InitStepsFlags  := 0;

   773     RealTicks       := 0;

   774     AttackBar       := 0; // 0 - none, 1 - just bar at the right-down corner, 2 - from weapon

   775     cCaseFactor     := 5;  {0..9}

   776     cLandMines      := 4;

   777     cExplosives     := 2;

   778 

   779     GameState       := Low(TGameState);

   780     GameType        := gmtLocal;

   781     zoom            := cDefaultZoomLevel;

   782     ZoomValue       := cDefaultZoomLevel;

   783     WeaponTooltipTex:= nil;

   784     cLaserSighting  := false;

   785     cVampiric       := false;

   786     cArtillery      := false;

   787     flagMakeCapture := false;

   788     bBetweenTurns   := false;

   789     bWaterRising    := false;

   790     isCursorVisible := false;

   791     isTerminated    := false;

   792     isInLag         := false;

   793     isPaused        := false;

   794     isInMultiShoot  := false;

   795     isSpeed         := false;

   796     fastUntilLag    := false;

   797     isFirstFrame    := true;

   798     isSEBackup      := true;

   799     cSeed           := '';

   800     cVolumeDelta    := 0;

   801     cHasFocus       := true;

   802     cInactDelay     := 1250;

   803     ReadyTimeLeft   := 0;

   804 

   805     ScreenFade      := sfNone;

   806 

   807 {$IFDEF SDL13}

   808     SDLwindow       := nil;

   809 {$ENDIF}

   810 

   811     // those values still aren't perfect

   812     cLeftScreenBorder:= round(-cMinZoomLevel * cScreenWidth);

   813     cRightScreenBorder:= round(cMinZoomLevel * cScreenWidth + LAND_WIDTH);

   814     cScreenSpace:= cRightScreenBorder - cLeftScreenBorder;

   815 

   816     if isPhone() then

   817         cMaxCaptions:= 3

   818     else

   819         cMaxCaptions:= 4;

   820 

   821 {$IFDEF DEBUGFILE}

   822 {$I-}

   823 {$IFDEF IPHONEOS}

   824     Assign(f,'../Documents/hw-' + cLogfileBase + '.log');

   825     Rewrite(f);

   826 {$ELSE}

   827     if (ParamStr(1) <> '') and (ParamStr(2) <> '') then

   828         if (ParamCount <> 3) and (ParamCount <> cDefaultParamNum) then

   829         begin

   830             for i:= 0 to 7 do

   831             begin

   832                 assign(f, ExtractFileDir(ParamStr(2)) + '/' + cLogfileBase + inttostr(i) + '.log');

   833                 rewrite(f);

   834                 if IOResult = 0 then break;

   835             end;

   836             if IOResult <> 0 then f:= stderr; // if everything fails, write to stderr

   837         end

   838         else

   839         begin

   840             for i:= 0 to 7 do

   841             begin

   842                 assign(f, ParamStr(1) + '/Logs/' + cLogfileBase + inttostr(i) + '.log');

   843                 rewrite(f);

   844                 if IOResult = 0 then break;

   845             end;

   846             if IOResult <> 0 then f:= stderr; // if everything fails, write to stderr

   847         end

   848     else

   849         f:= stderr;

   850 {$ENDIF}

   851 {$I+}

   852 {$ENDIF}

   858     while TextureList <> nil do FreeTexture(TextureList);

   859 

   860 {$IFDEF DEBUGFILE}

   861     writeln(f, 'halt at ', GameTicks, ' ticks. TurnTimeLeft = ', TurnTimeLeft);

   862     flush(f);

   863     close(f);

   864 {$ENDIF}

   865 

   866     // re-init flags so they will always contain safe values

   867     cScreenWidth    := 1024;

   868     cScreenHeight   := 768;

   869     cBits           := 32;

   870     //ipcPort is in uIO

   871     cFullScreen     := false;

   872     isSoundEnabled  := true;

   873     isMusicEnabled  := false;

   874     cLocaleFName    := 'en.txt';

   875     cInitVolume     := 100;

   876     cTimerInterval  := 8;

   877     PathPrefix := './';

   878     cShowFPS        := false;

   879     cAltDamage      := true;

   880     cReducedQuality := rqNone;

   881     //userNick is in uChat

   882     recordFileName  := '';

   883     cReadyDelay     := 0;