hedgewars/uLand.pas
author nemo
Thu, 01 Jul 2010 17:00:14 -0400
changeset 3603 b6b1989744ef
parent 3598 a8aa06bae895
child 3607 2ad7885615c1
permissions -rw-r--r--
Grid the landscape, and shortcircuit checks on the collision array if there are no nearby checked in collisions to be collided with. This is a big win for fire's ammoshove in particular. Also add a +2 that seemed missing in the check, and update fire accordingly.
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
     1
(*
1066
1f1b3686a2b0 Update copyright headers a bit
unc0rr
parents: 955
diff changeset
     2
 * Hedgewars, a free turn based strategy game
3236
4ab3917d7d44 Update (c) lines to 2010 as unc0rr requested - they all had varying values so I just took the first year mentioned, then tacked on -2010
nemo
parents: 3228
diff changeset
     3
 * Copyright (c) 2005-2010 Andrey Korotaev <unC0Rr@gmail.com>
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
     4
 *
183
57c2ef19f719 Relicense to GPL
unc0rr
parents: 173
diff changeset
     5
 * This program is free software; you can redistribute it and/or modify
57c2ef19f719 Relicense to GPL
unc0rr
parents: 173
diff changeset
     6
 * it under the terms of the GNU General Public License as published by
57c2ef19f719 Relicense to GPL
unc0rr
parents: 173
diff changeset
     7
 * the Free Software Foundation; version 2 of the License
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
     8
 *
183
57c2ef19f719 Relicense to GPL
unc0rr
parents: 173
diff changeset
     9
 * This program is distributed in the hope that it will be useful,
57c2ef19f719 Relicense to GPL
unc0rr
parents: 173
diff changeset
    10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
57c2ef19f719 Relicense to GPL
unc0rr
parents: 173
diff changeset
    11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
57c2ef19f719 Relicense to GPL
unc0rr
parents: 173
diff changeset
    12
 * GNU General Public License for more details.
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    13
 *
183
57c2ef19f719 Relicense to GPL
unc0rr
parents: 173
diff changeset
    14
 * You should have received a copy of the GNU General Public License
57c2ef19f719 Relicense to GPL
unc0rr
parents: 173
diff changeset
    15
 * along with this program; if not, write to the Free Software
57c2ef19f719 Relicense to GPL
unc0rr
parents: 173
diff changeset
    16
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    17
 *)
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    18
2599
c7153d2348f3 move compiler directives to standard pascal
koda
parents: 2592
diff changeset
    19
{$INCLUDE "options.inc"}
2587
0dfa56a8513c fix a segfault in the iphone simulator by moving options.inc at the beginning of the file
koda
parents: 2376
diff changeset
    20
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    21
unit uLand;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    22
interface
3165
3ec07a7d8456 just some very sane stuff for the iphone port (plus some macro on pascal files)
koda
parents: 3141
diff changeset
    23
uses SDLh, uLandTemplates, uFloat, uConsts, GLunit;
2699
249adefa9c1c replace initialization/finalization statements with custom init functions
koda
parents: 2692
diff changeset
    24
3509
d72c2219595d Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag)
nemo
parents: 3463
diff changeset
    25
type
d72c2219595d Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag)
nemo
parents: 3463
diff changeset
    26
{$IFDEF DOWNSCALE}
d72c2219595d Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag)
nemo
parents: 3463
diff changeset
    27
    TLandArray = packed array[0 .. LAND_HEIGHT div 2 - 1, 0 .. LAND_WIDTH div 2 - 1] of LongWord;
d72c2219595d Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag)
nemo
parents: 3463
diff changeset
    28
{$ELSE}
d72c2219595d Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag)
nemo
parents: 3463
diff changeset
    29
    TLandArray = packed array[0 .. LAND_HEIGHT - 1, 0 .. LAND_WIDTH - 1] of LongWord;
d72c2219595d Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag)
nemo
parents: 3463
diff changeset
    30
{$ENDIF}
d72c2219595d Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag)
nemo
parents: 3463
diff changeset
    31
 
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
    32
    TCollisionArray = packed array[0 .. LAND_HEIGHT - 1, 0 .. LAND_WIDTH - 1] of Word;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
    33
    TPreview  = packed array[0..127, 0..31] of byte;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
    34
    TDirtyTag = packed array[0 .. LAND_HEIGHT div 32 - 1, 0 .. LAND_WIDTH div 32 - 1] of byte;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    35
2699
249adefa9c1c replace initialization/finalization statements with custom init functions
koda
parents: 2692
diff changeset
    36
var Land: TCollisionArray;
249adefa9c1c replace initialization/finalization statements with custom init functions
koda
parents: 2692
diff changeset
    37
    LandPixels: TLandArray;
3603
b6b1989744ef Grid the landscape, and shortcircuit checks on the collision array if there are no nearby checked in collisions to be collided with. This is a big win for fire's ammoshove in particular. Also add a +2 that seemed missing in the check, and update fire accordingly.
nemo
parents: 3598
diff changeset
    38
// LandCollided is reusing DirtyTag size because currently the largest Radius we have is 32px (Piano)
b6b1989744ef Grid the landscape, and shortcircuit checks on the collision array if there are no nearby checked in collisions to be collided with. This is a big win for fire's ammoshove in particular. Also add a +2 that seemed missing in the check, and update fire accordingly.
nemo
parents: 3598
diff changeset
    39
    LandDirty, LandCollided: TDirtyTag;
2699
249adefa9c1c replace initialization/finalization statements with custom init functions
koda
parents: 2692
diff changeset
    40
    hasBorder: boolean; 
249adefa9c1c replace initialization/finalization statements with custom init functions
koda
parents: 2692
diff changeset
    41
    hasGirders: boolean;  
2981
d0471586a616 Fix basketball map and hog cannon.
nemo
parents: 2948
diff changeset
    42
    isMap: boolean;  
2699
249adefa9c1c replace initialization/finalization statements with custom init functions
koda
parents: 2692
diff changeset
    43
    playHeight, playWidth, leftX, rightX, topY, MaxHedgehogs: Longword;  // idea is that a template can specify height/width.  Or, a map, a height/width by the dimensions of the image.  If the map has pixels near top of image, it triggers border.
249adefa9c1c replace initialization/finalization statements with custom init functions
koda
parents: 2692
diff changeset
    44
    LandBackSurface: PSDL_Surface;
3369
c7289e42f0ee add other controls for map preview, also fix a bug in digest
koda
parents: 3365
diff changeset
    45
    digest: shortstring;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    46
3242
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
    47
type direction = record x, y: LongInt; end;
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
    48
const DIR_N: direction = (x: 0; y: -1);
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
    49
    DIR_E: direction = (x: 1; y: 0);
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
    50
    DIR_S: direction = (x: 0; y: 1);
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
    51
    DIR_W: direction = (x: -1; y: 0);
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
    52
3038
4e48c276a468 In pascal unit is a namespace
unc0rr
parents: 3017
diff changeset
    53
procedure initModule;
4e48c276a468 In pascal unit is a namespace
unc0rr
parents: 3017
diff changeset
    54
procedure freeModule;
37
2b7f2a43b999 - Properly get seed in net game
unc0rr
parents: 35
diff changeset
    55
procedure GenMap;
766
cdc8f75ab7bc - Update land texture after explosions
unc0rr
parents: 760
diff changeset
    56
function  GenPreview: TPreview;
367
bc3c3edc5ce1 Check land digest
unc0rr
parents: 365
diff changeset
    57
procedure CheckLandDigest(s: shortstring);
2692
ce9992075118 better network support + initial work for returning to frontend
koda
parents: 2665
diff changeset
    58
function  LandBackPixel(x, y: LongInt): LongWord;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    59
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    60
implementation
3526
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents: 3519
diff changeset
    61
uses uConsole, uStore, uMisc, uRandom, uTeams, uLandObjects, Adler32, uIO, uLandTexture;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    62
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
    63
operator=(const a, b: direction) c: Boolean;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
    64
begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
    65
    c := (a.x = b.x) and (a.y = b.y);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
    66
end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
    67
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    68
type TPixAr = record
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    69
              Count: Longword;
22
517be8dc5b76 - Fixed spawning boxes under water
unc0rr
parents: 10
diff changeset
    70
              ar: array[0..Pred(cMaxEdgePoints)] of TPoint;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    71
              end;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    72
37
2b7f2a43b999 - Properly get seed in net game
unc0rr
parents: 35
diff changeset
    73
procedure LogLandDigest;
3526
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents: 3519
diff changeset
    74
var s: shortstring;
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents: 3519
diff changeset
    75
    adler: LongInt;
37
2b7f2a43b999 - Properly get seed in net game
unc0rr
parents: 35
diff changeset
    76
begin
3526
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents: 3519
diff changeset
    77
adler:= 1;
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents: 3519
diff changeset
    78
Adler32Update(adler, @Land, sizeof(Land));
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents: 3519
diff changeset
    79
s:= 'M'+inttostr(adler);
a1d2180fef42 Replace SHA1 with adler32. For simple purposes of checking to see if players are playing the same map, this should be quite adequate and runs 15 times faster.
nemo
parents: 3519
diff changeset
    80
699
353382e07407 Fix previous commit
unc0rr
parents: 698
diff changeset
    81
CheckLandDigest(s);
367
bc3c3edc5ce1 Check land digest
unc0rr
parents: 365
diff changeset
    82
SendIPCRaw(@s[0], Length(s) + 1)
bc3c3edc5ce1 Check land digest
unc0rr
parents: 365
diff changeset
    83
end;
bc3c3edc5ce1 Check land digest
unc0rr
parents: 365
diff changeset
    84
bc3c3edc5ce1 Check land digest
unc0rr
parents: 365
diff changeset
    85
procedure CheckLandDigest(s: shortstring);
bc3c3edc5ce1 Check land digest
unc0rr
parents: 365
diff changeset
    86
begin
368
fe71e55d2d7b Make SHA really work
unc0rr
parents: 367
diff changeset
    87
{$IFDEF DEBUGFILE}
3369
c7289e42f0ee add other controls for map preview, also fix a bug in digest
koda
parents: 3365
diff changeset
    88
    AddFileLog('CheckLandDigest: ' + s + ' digest : ' + digest);
368
fe71e55d2d7b Make SHA really work
unc0rr
parents: 367
diff changeset
    89
{$ENDIF}
3369
c7289e42f0ee add other controls for map preview, also fix a bug in digest
koda
parents: 3365
diff changeset
    90
    if digest = '' then
c7289e42f0ee add other controls for map preview, also fix a bug in digest
koda
parents: 3365
diff changeset
    91
        digest:= s
c7289e42f0ee add other controls for map preview, also fix a bug in digest
koda
parents: 3365
diff changeset
    92
    else
c7289e42f0ee add other controls for map preview, also fix a bug in digest
koda
parents: 3365
diff changeset
    93
        TryDo(s = digest, 'Different maps generated, sorry', true);
37
2b7f2a43b999 - Properly get seed in net game
unc0rr
parents: 35
diff changeset
    94
end;
2b7f2a43b999 - Properly get seed in net game
unc0rr
parents: 35
diff changeset
    95
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
    96
procedure DrawLine(X1, Y1, X2, Y2: LongInt; Color: Longword);
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    97
var
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
    98
  eX, eY, dX, dY: LongInt;
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
    99
  i, sX, sY, x, y, d: LongInt;
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   100
begin
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   101
eX:= 0;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   102
eY:= 0;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   103
dX:= X2 - X1;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   104
dY:= Y2 - Y1;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   105
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   106
if (dX > 0) then sX:= 1
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   107
else
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   108
  if (dX < 0) then
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   109
     begin
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   110
     sX:= -1;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   111
     dX:= -dX
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   112
     end else sX:= dX;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   113
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   114
if (dY > 0) then sY:= 1
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   115
  else
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   116
  if (dY < 0) then
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   117
     begin
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   118
     sY:= -1;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   119
     dY:= -dY
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   120
     end else sY:= dY;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   121
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   122
if (dX > dY) then d:= dX
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   123
             else d:= dY;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   124
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   125
x:= X1;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   126
y:= Y1;
2376
ece7b87f1334 Strip trailing spaces
nemo
parents: 2338
diff changeset
   127
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   128
for i:= 0 to d do
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   129
    begin
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   130
    inc(eX, dX);
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   131
    inc(eY, dY);
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   132
    if (eX > d) then
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   133
       begin
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   134
       dec(eX, d);
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   135
       inc(x, sX);
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   136
       end;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   137
    if (eY > d) then
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   138
       begin
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   139
       dec(eY, d);
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   140
       inc(y, sY);
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   141
       end;
364
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   142
1753
2ccba26f1aa4 Apply nemo's world resize patch
unc0rr
parents: 1738
diff changeset
   143
    if ((x and LAND_WIDTH_MASK) = 0) and ((y and LAND_HEIGHT_MASK) = 0) then
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   144
       Land[y, x]:= Color;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   145
    end
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   146
end;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   147
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   148
procedure DrawEdge(var pa: TPixAr; Color: Longword);
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   149
var i: LongInt;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   150
begin
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   151
i:= 0;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   152
with pa do
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   153
while i < LongInt(Count) - 1 do
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   154
    if (ar[i + 1].X = NTPX) then inc(i, 2)
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   155
       else begin
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   156
       DrawLine(ar[i].x, ar[i].y, ar[i + 1].x, ar[i + 1].y, Color);
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   157
       inc(i)
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   158
       end
22
517be8dc5b76 - Fixed spawning boxes under water
unc0rr
parents: 10
diff changeset
   159
end;
517be8dc5b76 - Fixed spawning boxes under water
unc0rr
parents: 10
diff changeset
   160
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   161
procedure Vector(p1, p2, p3: TPoint; var Vx, Vy: hwFloat);
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   162
var d1, d2, d: hwFloat;
364
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   163
begin
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   164
Vx:= int2hwFloat(p1.X - p3.X);
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   165
Vy:= int2hwFloat(p1.Y - p3.Y);
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   166
d:= DistanceI(p2.X - p1.X, p2.Y - p1.Y);
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   167
d1:= DistanceI(p2.X - p3.X, p2.Y - p3.Y);
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   168
d2:= Distance(Vx, Vy);
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   169
if d1 < d then d:= d1;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   170
if d2 < d then d:= d2;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   171
d:= d * _1div3;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   172
if d2.QWordValue = 0 then
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   173
   begin
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   174
   Vx:= _0;
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   175
   Vy:= _0
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   176
   end else
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   177
   begin
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   178
   d2:= _1 / d2;
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   179
   Vx:= Vx * d2;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   180
   Vy:= Vy * d2;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   181
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   182
   Vx:= Vx * d;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   183
   Vy:= Vy * d
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   184
   end
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   185
end;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   186
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   187
procedure AddLoopPoints(var pa, opa: TPixAr; StartI, EndI: LongInt; Delta: hwFloat);
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   188
var i, pi, ni: LongInt;
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   189
    NVx, NVy, PVx, PVy: hwFloat;
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   190
    x1, x2, y1, y2: LongInt;
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   191
    tsq, tcb, t, r1, r2, r3, cx1, cx2, cy1, cy2: hwFloat;
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   192
    X, Y: LongInt;
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   193
begin
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   194
pi:= EndI;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   195
i:= StartI;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   196
ni:= Succ(StartI);
3407
dcc129c4352e Engine:
smxx
parents: 3369
diff changeset
   197
{$HINTS OFF}
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   198
Vector(opa.ar[pi], opa.ar[i], opa.ar[ni], NVx, NVy);
3407
dcc129c4352e Engine:
smxx
parents: 3369
diff changeset
   199
{$HINTS ON}
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   200
repeat
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   201
    inc(pi);
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   202
    if pi > EndI then pi:= StartI;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   203
    inc(i);
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   204
    if i > EndI then i:= StartI;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   205
    inc(ni);
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   206
    if ni > EndI then ni:= StartI;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   207
    PVx:= NVx;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   208
    PVy:= NVy;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   209
    Vector(opa.ar[pi], opa.ar[i], opa.ar[ni], NVx, NVy);
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   210
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   211
    x1:= opa.ar[pi].x;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   212
    y1:= opa.ar[pi].y;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   213
    x2:= opa.ar[i].x;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   214
    y2:= opa.ar[i].y;
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   215
    cx1:= int2hwFloat(x1) - PVx;
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   216
    cy1:= int2hwFloat(y1) - PVy;
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   217
    cx2:= int2hwFloat(x2) + NVx;
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   218
    cy2:= int2hwFloat(y2) + NVy;
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   219
    t:= _0;
364
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   220
    while t.Round = 0 do
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   221
          begin
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   222
          tsq:= t * t;
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   223
          tcb:= tsq * t;
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   224
          r1:= (_1 - t*3 + tsq*3 - tcb);
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   225
          r2:= (     t*3 - tsq*6 + tcb*3);
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   226
          r3:= (           tsq*3 - tcb*3);
430
57d05fb13ea7 Small performance optimization
unc0rr
parents: 429
diff changeset
   227
          X:= hwRound(r1 * x1 + r2 * cx1 + r3 * cx2 + tcb * x2);
57d05fb13ea7 Small performance optimization
unc0rr
parents: 429
diff changeset
   228
          Y:= hwRound(r1 * y1 + r2 * cy1 + r3 * cy2 + tcb * y2);
364
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   229
          t:= t + Delta;
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   230
          pa.ar[pa.Count].x:= X;
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   231
          pa.ar[pa.Count].y:= Y;
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   232
          inc(pa.Count);
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   233
          TryDo(pa.Count <= cMaxEdgePoints, 'Edge points overflow', true)
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   234
          end;
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   235
until i = StartI;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   236
pa.ar[pa.Count].x:= opa.ar[StartI].X;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   237
pa.ar[pa.Count].y:= opa.ar[StartI].Y;
364
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   238
inc(pa.Count)
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   239
end;
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   240
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   241
procedure BezierizeEdge(var pa: TPixAr; Delta: hwFloat);
495
62c1c2b4414c - Fix most of the warnings in hwengine
unc0rr
parents: 431
diff changeset
   242
var i, StartLoop: LongInt;
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   243
    opa: TPixAr;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   244
begin
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   245
opa:= pa;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   246
pa.Count:= 0;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   247
i:= 0;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   248
StartLoop:= 0;
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   249
while i < LongInt(opa.Count) do
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   250
    if (opa.ar[i + 1].X = NTPX) then
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   251
       begin
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   252
       AddLoopPoints(pa, opa, StartLoop, i, Delta);
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   253
       inc(i, 2);
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   254
       StartLoop:= i;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   255
       pa.ar[pa.Count].X:= NTPX;
3224
f5f4c611bcac possible map gen desync "fix" -- test please
sheepluva
parents: 3181
diff changeset
   256
       pa.ar[pa.Count].Y:= 0;
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   257
       inc(pa.Count);
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   258
       end else inc(i)
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   259
end;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   260
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   261
procedure FillLand(x, y: LongInt);
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   262
var Stack: record
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   263
           Count: Longword;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   264
           points: array[0..8192] of record
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   265
                                     xl, xr, y, dir: LongInt;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   266
                                     end
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   267
           end;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   268
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   269
    procedure Push(_xl, _xr, _y, _dir: LongInt);
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   270
    begin
75
d2b737858ff7 - New First Aid powerup
unc0rr
parents: 74
diff changeset
   271
    TryDo(Stack.Count <= 8192, 'FillLand: stack overflow', true);
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   272
    _y:= _y + _dir;
1760
55a1edd97911 Fix nemo's large land patch
unc0rr
parents: 1754
diff changeset
   273
    if (_y < 0) or (_y >= LAND_HEIGHT) then exit;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   274
    with Stack.points[Stack.Count] do
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   275
         begin
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   276
         xl:= _xl;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   277
         xr:= _xr;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   278
         y:= _y;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   279
         dir:= _dir
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   280
         end;
75
d2b737858ff7 - New First Aid powerup
unc0rr
parents: 74
diff changeset
   281
    inc(Stack.Count)
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   282
    end;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   283
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   284
    procedure Pop(var _xl, _xr, _y, _dir: LongInt);
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   285
    begin
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   286
    dec(Stack.Count);
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   287
    with Stack.points[Stack.Count] do
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   288
         begin
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   289
         _xl:= xl;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   290
         _xr:= xr;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   291
         _y:= y;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   292
         _dir:= dir
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   293
         end
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   294
    end;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   295
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   296
var xl, xr, dir: LongInt;
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents: 316
diff changeset
   297
begin
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   298
Stack.Count:= 0;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   299
xl:= x - 1;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   300
xr:= x;
23
16322d14f068 - Land generator uses templates to generate
unc0rr
parents: 22
diff changeset
   301
Push(xl, xr, y, -1);
16322d14f068 - Land generator uses templates to generate
unc0rr
parents: 22
diff changeset
   302
Push(xl, xr, y,  1);
3407
dcc129c4352e Engine:
smxx
parents: 3369
diff changeset
   303
dir:= 0;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   304
while Stack.Count > 0 do
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   305
      begin
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   306
      Pop(xl, xr, y, dir);
51
b6e3ae05857f - Get rid of hwserv and runhelper
unc0rr
parents: 37
diff changeset
   307
      while (xl > 0) and (Land[y, xl] <> 0) do dec(xl);
1760
55a1edd97911 Fix nemo's large land patch
unc0rr
parents: 1754
diff changeset
   308
      while (xr < LAND_WIDTH - 1) and (Land[y, xr] <> 0) do inc(xr);
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   309
      while (xl < xr) do
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   310
            begin
51
b6e3ae05857f - Get rid of hwserv and runhelper
unc0rr
parents: 37
diff changeset
   311
            while (xl <= xr) and (Land[y, xl] = 0) do inc(xl);
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   312
            x:= xl;
51
b6e3ae05857f - Get rid of hwserv and runhelper
unc0rr
parents: 37
diff changeset
   313
            while (xl <= xr) and (Land[y, xl] <> 0) do
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   314
                  begin
51
b6e3ae05857f - Get rid of hwserv and runhelper
unc0rr
parents: 37
diff changeset
   315
                  Land[y, xl]:= 0;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   316
                  inc(xl)
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   317
                  end;
22
517be8dc5b76 - Fixed spawning boxes under water
unc0rr
parents: 10
diff changeset
   318
            if x < xl then
517be8dc5b76 - Fixed spawning boxes under water
unc0rr
parents: 10
diff changeset
   319
               begin
517be8dc5b76 - Fixed spawning boxes under water
unc0rr
parents: 10
diff changeset
   320
               Push(x, Pred(xl), y, dir);
517be8dc5b76 - Fixed spawning boxes under water
unc0rr
parents: 10
diff changeset
   321
               Push(x, Pred(xl), y,-dir);
517be8dc5b76 - Fixed spawning boxes under water
unc0rr
parents: 10
diff changeset
   322
               end;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   323
            end;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   324
      end;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   325
end;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   326
2647
0e1208e92dfe Smaxx patch with tuning by me:
unc0rr
parents: 2619
diff changeset
   327
function LandBackPixel(x, y: LongInt): LongWord;
0e1208e92dfe Smaxx patch with tuning by me:
unc0rr
parents: 2619
diff changeset
   328
var p: PLongWordArray;
0e1208e92dfe Smaxx patch with tuning by me:
unc0rr
parents: 2619
diff changeset
   329
begin
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   330
    if LandBackSurface = nil then LandBackPixel:= 0
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   331
    else
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   332
    begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   333
        p:= LandBackSurface^.pixels;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   334
        LandBackPixel:= p^[LandBackSurface^.w * (y mod LandBackSurface^.h) + (x mod LandBackSurface^.w)];// or $FF000000;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   335
    end
2647
0e1208e92dfe Smaxx patch with tuning by me:
unc0rr
parents: 2619
diff changeset
   336
end;
0e1208e92dfe Smaxx patch with tuning by me:
unc0rr
parents: 2619
diff changeset
   337
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   338
procedure ColorizeLand(Surface: PSDL_Surface);
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   339
var tmpsurf: PSDL_Surface;
1182
e2e13aa055c1 Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents: 1181
diff changeset
   340
    r, rr: TSDL_Rect;
e2e13aa055c1 Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents: 1181
diff changeset
   341
    x, yd, yu: LongInt;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   342
begin
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   343
    tmpsurf:= LoadImage(Pathz[ptCurrTheme] + '/LandTex', ifCritical or ifIgnoreCaps);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   344
    r.y:= 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   345
    while r.y < LAND_HEIGHT do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   346
    begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   347
        r.x:= 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   348
        while r.x < LAND_WIDTH do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   349
        begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   350
            SDL_UpperBlit(tmpsurf, nil, Surface, @r);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   351
            inc(r.x, tmpsurf^.w)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   352
        end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   353
        inc(r.y, tmpsurf^.h)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   354
    end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   355
    SDL_FreeSurface(tmpsurf);
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   356
3038
4e48c276a468 In pascal unit is a namespace
unc0rr
parents: 3017
diff changeset
   357
    // freed in freeModule() below
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   358
    LandBackSurface:= LoadImage(Pathz[ptCurrTheme] + '/LandBackTex', ifIgnoreCaps or ifTransparent);
2647
0e1208e92dfe Smaxx patch with tuning by me:
unc0rr
parents: 2619
diff changeset
   359
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   360
    tmpsurf:= LoadImage(Pathz[ptCurrTheme] + '/Border', ifCritical or ifIgnoreCaps or ifTransparent);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   361
    for x:= 0 to LAND_WIDTH - 1 do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   362
    begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   363
        yd:= LAND_HEIGHT - 1;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   364
        repeat
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   365
            while (yd > 0) and (Land[yd, x] =  0) do dec(yd);
2376
ece7b87f1334 Strip trailing spaces
nemo
parents: 2338
diff changeset
   366
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   367
            if (yd < 0) then yd:= 0;
1182
e2e13aa055c1 Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents: 1181
diff changeset
   368
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   369
            while (yd < LAND_HEIGHT) and (Land[yd, x] <> 0) do inc(yd);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   370
            dec(yd);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   371
            yu:= yd;
2376
ece7b87f1334 Strip trailing spaces
nemo
parents: 2338
diff changeset
   372
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   373
            while (yu > 0  ) and (Land[yu, x] <> 0) do dec(yu);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   374
            while (yu < yd ) and (Land[yu, x] =  0) do inc(yu);
2376
ece7b87f1334 Strip trailing spaces
nemo
parents: 2338
diff changeset
   375
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   376
            if (yd < LAND_HEIGHT - 1) and ((yd - yu) >= 16) then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   377
            begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   378
                rr.x:= x;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   379
                rr.y:= yd - 15;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   380
                r.x:= x mod tmpsurf^.w;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   381
                r.y:= 16;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   382
                r.w:= 1;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   383
                r.h:= 16;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   384
                SDL_UpperBlit(tmpsurf, @r, Surface, @rr);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   385
            end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   386
            if (yu > 0) then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   387
            begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   388
                rr.x:= x;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   389
                rr.y:= yu;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   390
                r.x:= x mod tmpsurf^.w;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   391
                r.y:= 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   392
                r.w:= 1;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   393
                r.h:= min(16, yd - yu + 1);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   394
                SDL_UpperBlit(tmpsurf, @r, Surface, @rr);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   395
            end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   396
            yd:= yu - 1;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   397
        until yd < 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   398
    end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   399
    SDL_FreeSurface(tmpsurf);
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   400
end;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   401
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   402
procedure SetPoints(var Template: TEdgeTemplate; var pa: TPixAr);
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   403
var i: LongInt;
22
517be8dc5b76 - Fixed spawning boxes under water
unc0rr
parents: 10
diff changeset
   404
begin
23
16322d14f068 - Land generator uses templates to generate
unc0rr
parents: 22
diff changeset
   405
with Template do
16322d14f068 - Land generator uses templates to generate
unc0rr
parents: 22
diff changeset
   406
     begin
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   407
     pa.Count:= BasePointsCount;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   408
     for i:= 0 to pred(pa.Count) do
23
16322d14f068 - Land generator uses templates to generate
unc0rr
parents: 22
diff changeset
   409
         begin
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   410
         pa.ar[i].x:= BasePoints^[i].x + LongInt(GetRandom(BasePoints^[i].w));
1792
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
   411
         if pa.ar[i].x <> NTPX then
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
   412
            pa.ar[i].x:= pa.ar[i].x + ((LAND_WIDTH - Template.TemplateWidth) div 2);
3407
dcc129c4352e Engine:
smxx
parents: 3369
diff changeset
   413
         pa.ar[i].y:= BasePoints^[i].y + LongInt(GetRandom(BasePoints^[i].h)) + LAND_HEIGHT - LongInt(Template.TemplateHeight)
23
16322d14f068 - Land generator uses templates to generate
unc0rr
parents: 22
diff changeset
   414
         end;
1183
540cea859395 Step 4: repair girder rendering (girder is 32bit now)
unc0rr
parents: 1182
diff changeset
   415
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   416
     if canMirror then
360
ab6a94334d6d - Two more templates
unc0rr
parents: 359
diff changeset
   417
        if getrandom(2) = 0 then
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   418
           begin
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   419
           for i:= 0 to pred(BasePointsCount) do
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   420
             if pa.ar[i].x <> NTPX then
1760
55a1edd97911 Fix nemo's large land patch
unc0rr
parents: 1754
diff changeset
   421
               pa.ar[i].x:= LAND_WIDTH - 1 - pa.ar[i].x;
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   422
           for i:= 0 to pred(FillPointsCount) do
1760
55a1edd97911 Fix nemo's large land patch
unc0rr
parents: 1754
diff changeset
   423
               FillPoints^[i].x:= LAND_WIDTH - 1 - FillPoints^[i].x;
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   424
           end;
22
517be8dc5b76 - Fixed spawning boxes under water
unc0rr
parents: 10
diff changeset
   425
2338
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   426
(*  Experiment in making this option more useful
2376
ece7b87f1334 Strip trailing spaces
nemo
parents: 2338
diff changeset
   427
     if ((not isNegative) and (cTemplateFilter = 4)) or
2338
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   428
        (canFlip and (getrandom(2) = 0)) then
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   429
           begin
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   430
           for i:= 0 to pred(BasePointsCount) do
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   431
               begin
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   432
               pa.ar[i].y:= LAND_HEIGHT - 1 - pa.ar[i].y + (LAND_HEIGHT - TemplateHeight) * 2;
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   433
               if pa.ar[i].y > LAND_HEIGHT - 1 then
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   434
                   pa.ar[i].y:= LAND_HEIGHT - 1;
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   435
               end;
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   436
           for i:= 0 to pred(FillPointsCount) do
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   437
               begin
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   438
               FillPoints^[i].y:= LAND_HEIGHT - 1 - FillPoints^[i].y + (LAND_HEIGHT - TemplateHeight) * 2;
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   439
               if FillPoints^[i].y > LAND_HEIGHT - 1 then
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   440
                   FillPoints^[i].y:= LAND_HEIGHT - 1;
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   441
               end;
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   442
           end;
2376
ece7b87f1334 Strip trailing spaces
nemo
parents: 2338
diff changeset
   443
     end
2338
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   444
*)
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   445
// template recycling.  Pull these off the floor a bit
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   446
     if (not isNegative) and (cTemplateFilter = 4) then
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   447
           begin
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   448
           for i:= 0 to pred(BasePointsCount) do
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   449
               begin
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   450
               dec(pa.ar[i].y, 100);
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   451
               if pa.ar[i].y < 0 then
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   452
                   pa.ar[i].y:= 0;
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   453
               end;
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   454
           for i:= 0 to pred(FillPointsCount) do
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   455
               begin
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   456
               dec(FillPoints^[i].y, 100);
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   457
               if FillPoints^[i].y < 0 then
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   458
                   FillPoints^[i].y:= 0;
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   459
               end;
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   460
           end;
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   461
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   462
     if (canFlip and (getrandom(2) = 0)) then
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   463
           begin
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   464
           for i:= 0 to pred(BasePointsCount) do
1760
55a1edd97911 Fix nemo's large land patch
unc0rr
parents: 1754
diff changeset
   465
               pa.ar[i].y:= LAND_HEIGHT - 1 - pa.ar[i].y;
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   466
           for i:= 0 to pred(FillPointsCount) do
1760
55a1edd97911 Fix nemo's large land patch
unc0rr
parents: 1754
diff changeset
   467
               FillPoints^[i].y:= LAND_HEIGHT - 1 - FillPoints^[i].y;
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   468
           end;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   469
     end
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   470
end;
67
3101306251e5 - 2 more Land templates
unc0rr
parents: 64
diff changeset
   471
561
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   472
function CheckIntersect(V1, V2, V3, V4: TPoint): boolean;
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   473
var c1, c2, dm: LongInt;
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   474
begin
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   475
dm:= (V4.y - V3.y) * (V2.x - V1.x) - (V4.x - V3.x) * (V2.y - V1.y);
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   476
c1:= (V4.x - V3.x) * (V1.y - V3.y) - (V4.y - V3.y) * (V1.x - V3.x);
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   477
if dm = 0 then exit(false);
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   478
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   479
c2:= (V2.x - V3.x) * (V1.y - V3.y) - (V2.y - V3.y) * (V1.x - V3.x);
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   480
if dm > 0 then
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   481
   begin
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   482
   if (c1 < 0) or (c1 > dm) then exit(false);
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   483
   if (c2 < 0) or (c2 > dm) then exit(false)
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   484
   end else
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   485
   begin
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   486
   if (c1 > 0) or (c1 < dm) then exit(false);
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   487
   if (c2 > 0) or (c2 < dm) then exit(false)
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   488
   end;
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   489
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   490
//AddFileLog('1  (' + inttostr(V1.x) + ',' + inttostr(V1.y) + ')x(' + inttostr(V2.x) + ',' + inttostr(V2.y) + ')');
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   491
//AddFileLog('2  (' + inttostr(V3.x) + ',' + inttostr(V3.y) + ')x(' + inttostr(V4.x) + ',' + inttostr(V4.y) + ')');
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   492
CheckIntersect:= true
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   493
end;
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   494
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   495
function CheckSelfIntersect(var pa: TPixAr; ind: Longword): boolean;
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   496
var i: Longword;
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   497
begin
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   498
if (ind <= 0) or (ind >= Pred(pa.Count)) then exit(false);
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   499
for i:= 1 to pa.Count - 3 do
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   500
    if (i <= ind - 1) or (i >= ind + 2) then
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   501
      begin
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   502
      if (i <> ind - 1) and
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   503
         CheckIntersect(pa.ar[ind], pa.ar[ind - 1], pa.ar[i], pa.ar[i - 1]) then exit(true);
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   504
      if (i <> ind + 2) and
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   505
         CheckIntersect(pa.ar[ind], pa.ar[ind + 1], pa.ar[i], pa.ar[i - 1]) then exit(true);
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   506
      end;
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   507
CheckSelfIntersect:= false
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   508
end;
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   509
429
7f69c7ac2e97 One more land template + some templates tuning
unc0rr
parents: 393
diff changeset
   510
procedure RandomizePoints(var pa: TPixAr);
364
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   511
const cEdge = 55;
561
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   512
      cMinDist = 8;
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   513
var radz: array[0..Pred(cMaxEdgePoints)] of LongInt;
561
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   514
    i, k, dist, px, py: LongInt;
364
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   515
begin
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   516
for i:= 0 to Pred(pa.Count) do
3225
5d8f4737b6cd another uninitialised value radz[k] for corresponding pa.ar of NTPX
nemo
parents: 3224
diff changeset
   517
  begin
5d8f4737b6cd another uninitialised value radz[k] for corresponding pa.ar of NTPX
nemo
parents: 3224
diff changeset
   518
  radz[i]:= 0;
364
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   519
  with pa.ar[i] do
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   520
    if x <> NTPX then
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   521
      begin
1760
55a1edd97911 Fix nemo's large land patch
unc0rr
parents: 1754
diff changeset
   522
      radz[i]:= Min(Max(x - cEdge, 0), Max(LAND_WIDTH - cEdge - x, 0));
55a1edd97911 Fix nemo's large land patch
unc0rr
parents: 1754
diff changeset
   523
      radz[i]:= Min(radz[i], Min(Max(y - cEdge, 0), Max(LAND_HEIGHT - cEdge - y, 0)));
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   524
      if radz[i] > 0 then
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   525
        for k:= 0 to Pred(i) do
364
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   526
          begin
429
7f69c7ac2e97 One more land template + some templates tuning
unc0rr
parents: 393
diff changeset
   527
          dist:= Max(abs(x - pa.ar[k].x), abs(y - pa.ar[k].y));
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   528
          radz[k]:= Max(0, Min((dist - cMinDist) div 2, radz[k]));
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   529
          radz[i]:= Max(0, Min(dist - radz[k] - cMinDist, radz[i]))
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   530
        end
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   531
      end;
3225
5d8f4737b6cd another uninitialised value radz[k] for corresponding pa.ar of NTPX
nemo
parents: 3224
diff changeset
   532
  end;
364
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   533
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   534
for i:= 0 to Pred(pa.Count) do
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   535
  with pa.ar[i] do
1753
2ccba26f1aa4 Apply nemo's world resize patch
unc0rr
parents: 1738
diff changeset
   536
    if ((x and LAND_WIDTH_MASK) = 0) and ((y and LAND_HEIGHT_MASK) = 0) then
364
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   537
      begin
561
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   538
      px:= x;
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   539
      py:= y;
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   540
      x:= x + LongInt(GetRandom(7) - 3) * (radz[i] * 5 div 7) div 3;
561
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   541
      y:= y + LongInt(GetRandom(7) - 3) * (radz[i] * 5 div 7) div 3;
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   542
      if CheckSelfIntersect(pa, i) then
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   543
         begin
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   544
         x:= px;
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   545
         y:= py
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   546
         end;
364
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   547
      end
67
3101306251e5 - 2 more Land templates
unc0rr
parents: 64
diff changeset
   548
end;
3101306251e5 - 2 more Land templates
unc0rr
parents: 64
diff changeset
   549
364
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   550
23
16322d14f068 - Land generator uses templates to generate
unc0rr
parents: 22
diff changeset
   551
procedure GenBlank(var Template: TEdgeTemplate);
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   552
var pa: TPixAr;
23
16322d14f068 - Land generator uses templates to generate
unc0rr
parents: 22
diff changeset
   553
    i: Longword;
155
401f4ea24715 Engine can generate land preview and send it via IPC
unc0rr
parents: 109
diff changeset
   554
    y, x: Longword;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   555
begin
1760
55a1edd97911 Fix nemo's large land patch
unc0rr
parents: 1754
diff changeset
   556
for y:= 0 to LAND_HEIGHT - 1 do
55a1edd97911 Fix nemo's large land patch
unc0rr
parents: 1754
diff changeset
   557
    for x:= 0 to LAND_WIDTH - 1 do
3519
56cbc035b74b rename flags
nemo
parents: 3513
diff changeset
   558
        Land[y, x]:= lfBasic;
155
401f4ea24715 Engine can generate land preview and send it via IPC
unc0rr
parents: 109
diff changeset
   559
3407
dcc129c4352e Engine:
smxx
parents: 3369
diff changeset
   560
{$HINTS OFF}
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   561
SetPoints(Template, pa);
3407
dcc129c4352e Engine:
smxx
parents: 3369
diff changeset
   562
{$HINTS ON}
429
7f69c7ac2e97 One more land template + some templates tuning
unc0rr
parents: 393
diff changeset
   563
for i:= 1 to Template.BezierizeCount do
7f69c7ac2e97 One more land template + some templates tuning
unc0rr
parents: 393
diff changeset
   564
    begin
431
79ac59673df3 - Two more land templates
unc0rr
parents: 430
diff changeset
   565
    BezierizeEdge(pa, _0_5);
561
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   566
    RandomizePoints(pa);
429
7f69c7ac2e97 One more land template + some templates tuning
unc0rr
parents: 393
diff changeset
   567
    RandomizePoints(pa)
7f69c7ac2e97 One more land template + some templates tuning
unc0rr
parents: 393
diff changeset
   568
    end;
7f69c7ac2e97 One more land template + some templates tuning
unc0rr
parents: 393
diff changeset
   569
for i:= 1 to Template.RandPassesCount do RandomizePoints(pa);
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   570
BezierizeEdge(pa, _0_1);
27
c374fe590272 - improve land generation
unc0rr
parents: 24
diff changeset
   571
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   572
DrawEdge(pa, 0);
27
c374fe590272 - improve land generation
unc0rr
parents: 24
diff changeset
   573
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   574
with Template do
23
16322d14f068 - Land generator uses templates to generate
unc0rr
parents: 22
diff changeset
   575
     for i:= 0 to pred(FillPointsCount) do
16322d14f068 - Land generator uses templates to generate
unc0rr
parents: 22
diff changeset
   576
         with FillPoints^[i] do
89
f9db56409a86 - Fix various bugs
unc0rr
parents: 80
diff changeset
   577
              FillLand(x, y);
f9db56409a86 - Fix various bugs
unc0rr
parents: 80
diff changeset
   578
3519
56cbc035b74b rename flags
nemo
parents: 3513
diff changeset
   579
DrawEdge(pa, lfBasic);
1773
bc6ad6136675 nemo's template patch (invertion)
unc0rr
parents: 1772
diff changeset
   580
1792
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
   581
MaxHedgehogs:= Template.MaxHedgehogs;
1776
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
   582
hasGirders:= Template.hasGirders;
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
   583
playHeight:= Template.TemplateHeight;
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
   584
playWidth:= Template.TemplateWidth;
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
   585
leftX:= ((LAND_WIDTH - playWidth) div 2);
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
   586
rightX:= (playWidth + ((LAND_WIDTH - playWidth) div 2)) - 1;
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
   587
topY:= LAND_HEIGHT - playHeight;
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
   588
1797
fedd8649fdd9 Templates filter by nemo
unc0rr
parents: 1795
diff changeset
   589
// force to only cavern even if a cavern map is invertable if cTemplateFilter = 4 ?
2376
ece7b87f1334 Strip trailing spaces
nemo
parents: 2338
diff changeset
   590
if (cTemplateFilter = 4) or
2338
8f6508c97f3f An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents: 2308
diff changeset
   591
   (Template.canInvert and (getrandom(2) = 0)) or
2376
ece7b87f1334 Strip trailing spaces
nemo
parents: 2338
diff changeset
   592
    (not Template.canInvert and Template.isNegative) then
1776
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
   593
    begin
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
   594
    hasBorder:= true;
1773
bc6ad6136675 nemo's template patch (invertion)
unc0rr
parents: 1772
diff changeset
   595
    for y:= 0 to LAND_HEIGHT - 1 do
bc6ad6136675 nemo's template patch (invertion)
unc0rr
parents: 1772
diff changeset
   596
        for x:= 0 to LAND_WIDTH - 1 do
1776
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
   597
            if (y < topY) or (x < leftX) or (x > rightX) then
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
   598
                Land[y, x]:= 0
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
   599
            else
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
   600
            begin
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
   601
               if Land[y, x] = 0 then
3519
56cbc035b74b rename flags
nemo
parents: 3513
diff changeset
   602
                   Land[y, x]:= lfBasic
56cbc035b74b rename flags
nemo
parents: 3513
diff changeset
   603
               else if Land[y, x] = lfBasic then
1776
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
   604
                   Land[y, x]:= 0;
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
   605
            end;
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
   606
    end;
23
16322d14f068 - Land generator uses templates to generate
unc0rr
parents: 22
diff changeset
   607
end;
16322d14f068 - Land generator uses templates to generate
unc0rr
parents: 22
diff changeset
   608
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   609
function SelectTemplate: LongInt;
161
d8870bbf960e - AmmoMenu
unc0rr
parents: 160
diff changeset
   610
begin
1797
fedd8649fdd9 Templates filter by nemo
unc0rr
parents: 1795
diff changeset
   611
case cTemplateFilter of
fedd8649fdd9 Templates filter by nemo
unc0rr
parents: 1795
diff changeset
   612
     0: begin
fedd8649fdd9 Templates filter by nemo
unc0rr
parents: 1795
diff changeset
   613
     SelectTemplate:= getrandom(Succ(High(EdgeTemplates)));
fedd8649fdd9 Templates filter by nemo
unc0rr
parents: 1795
diff changeset
   614
     end;
fedd8649fdd9 Templates filter by nemo
unc0rr
parents: 1795
diff changeset
   615
     1: begin
fedd8649fdd9 Templates filter by nemo
unc0rr
parents: 1795
diff changeset
   616
     SelectTemplate:= SmallTemplates[getrandom(Succ(High(SmallTemplates)))];
fedd8649fdd9 Templates filter by nemo
unc0rr
parents: 1795
diff changeset
   617
     end;
fedd8649fdd9 Templates filter by nemo
unc0rr
parents: 1795
diff changeset
   618
     2: begin
fedd8649fdd9 Templates filter by nemo
unc0rr
parents: 1795
diff changeset
   619
     SelectTemplate:= MediumTemplates[getrandom(Succ(High(MediumTemplates)))];
fedd8649fdd9 Templates filter by nemo
unc0rr
parents: 1795
diff changeset
   620
     end;
fedd8649fdd9 Templates filter by nemo
unc0rr
parents: 1795
diff changeset
   621
     3: begin
fedd8649fdd9 Templates filter by nemo
unc0rr
parents: 1795
diff changeset
   622
     SelectTemplate:= LargeTemplates[getrandom(Succ(High(LargeTemplates)))];
fedd8649fdd9 Templates filter by nemo
unc0rr
parents: 1795
diff changeset
   623
     end;
fedd8649fdd9 Templates filter by nemo
unc0rr
parents: 1795
diff changeset
   624
     4: begin
fedd8649fdd9 Templates filter by nemo
unc0rr
parents: 1795
diff changeset
   625
     SelectTemplate:= CavernTemplates[getrandom(Succ(High(CavernTemplates)))];
fedd8649fdd9 Templates filter by nemo
unc0rr
parents: 1795
diff changeset
   626
     end;
fedd8649fdd9 Templates filter by nemo
unc0rr
parents: 1795
diff changeset
   627
     5: begin
fedd8649fdd9 Templates filter by nemo
unc0rr
parents: 1795
diff changeset
   628
     SelectTemplate:= WackyTemplates[getrandom(Succ(High(WackyTemplates)))];
fedd8649fdd9 Templates filter by nemo
unc0rr
parents: 1795
diff changeset
   629
     end;
fedd8649fdd9 Templates filter by nemo
unc0rr
parents: 1795
diff changeset
   630
end;
fedd8649fdd9 Templates filter by nemo
unc0rr
parents: 1795
diff changeset
   631
WriteLnToConsole('Selected template #'+inttostr(SelectTemplate)+' using filter #'+inttostr(cTemplateFilter));
161
d8870bbf960e - AmmoMenu
unc0rr
parents: 160
diff changeset
   632
end;
d8870bbf960e - AmmoMenu
unc0rr
parents: 160
diff changeset
   633
1182
e2e13aa055c1 Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents: 1181
diff changeset
   634
procedure LandSurface2LandPixels(Surface: PSDL_Surface);
e2e13aa055c1 Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents: 1181
diff changeset
   635
var x, y: LongInt;
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   636
    p: PLongwordArray;
1180
e56317fdf78d Start implementing support for 32bit sprites concerned in map generation process.
unc0rr
parents: 1085
diff changeset
   637
begin
1182
e2e13aa055c1 Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents: 1181
diff changeset
   638
TryDo(Surface <> nil, 'Assert (LandSurface <> nil) failed', true);
e2e13aa055c1 Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents: 1181
diff changeset
   639
e2e13aa055c1 Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents: 1181
diff changeset
   640
if SDL_MustLock(Surface) then
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   641
    SDLTry(SDL_LockSurface(Surface) >= 0, true);
1180
e56317fdf78d Start implementing support for 32bit sprites concerned in map generation process.
unc0rr
parents: 1085
diff changeset
   642
1182
e2e13aa055c1 Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents: 1181
diff changeset
   643
p:= Surface^.pixels;
1760
55a1edd97911 Fix nemo's large land patch
unc0rr
parents: 1754
diff changeset
   644
for y:= 0 to LAND_HEIGHT - 1 do
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   645
    begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   646
    for x:= 0 to LAND_WIDTH - 1 do
3598
a8aa06bae895 tiy new overlay graphics
koda
parents: 3595
diff changeset
   647
    if Land[y, x] <> 0 then
3595
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
   648
        if (cReducedQuality and rqBlurryLand) = 0 then
3598
a8aa06bae895 tiy new overlay graphics
koda
parents: 3595
diff changeset
   649
             LandPixels[y, x]:= p^[x] or AMask
3595
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
   650
        else
3598
a8aa06bae895 tiy new overlay graphics
koda
parents: 3595
diff changeset
   651
             LandPixels[y div 2, x div 2]:= p^[x] or AMask;
2376
ece7b87f1334 Strip trailing spaces
nemo
parents: 2338
diff changeset
   652
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   653
    p:= @(p^[Surface^.pitch div 4]);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   654
    end;
1180
e56317fdf78d Start implementing support for 32bit sprites concerned in map generation process.
unc0rr
parents: 1085
diff changeset
   655
1182
e2e13aa055c1 Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents: 1181
diff changeset
   656
if SDL_MustLock(Surface) then
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   657
    SDL_UnlockSurface(Surface);
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
   658
end;
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
   659
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   660
procedure GenMaze;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   661
const small_cell_size = 128;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   662
    medium_cell_size = 192;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   663
    large_cell_size = 256;
3138
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   664
    braidness = 10;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   665
3242
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   666
var x, y: LongInt;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   667
    cellsize: LongInt; //selected by the user in the gui
3242
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   668
    seen_cells_x, seen_cells_y: LongInt; //number of cells that can be visited by the generator, that is every second cell in x and y direction. the cells between there are walls that will be removed when we move from one cell to another
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   669
    num_edges_x, num_edges_y: LongInt; //number of resulting edges that need to be vertexificated
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   670
    num_cells_x, num_cells_y: LongInt; //actual number of cells, depending on cell size
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   671
    seen_list: array of array of LongInt;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   672
    xwalls: array of array of Boolean;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   673
    ywalls: array of array of Boolean;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   674
    x_edge_list: array of array of Boolean;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   675
    y_edge_list: array of array of Boolean;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   676
    maze: array of array of Boolean;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   677
    pa: TPixAr;
3242
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   678
    num_vertices: LongInt;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   679
    off_y: LongInt;
3242
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   680
    num_steps: LongInt;
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   681
    current_step: LongInt;
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   682
    step_done: array of Boolean;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   683
    done: Boolean;
3242
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   684
    last_cell: array of record x, y: LongInt; end;
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   685
    came_from: array of array of record x, y: LongInt; end;
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   686
    came_from_pos: array of LongInt;
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   687
    maze_inverted: Boolean;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   688
3242
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   689
function when_seen(x: LongInt; y: LongInt): LongInt;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   690
begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   691
if (x < 0) or (x >= seen_cells_x) or (y < 0) or (y >= seen_cells_y) then
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   692
    when_seen := current_step
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   693
else
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   694
    when_seen := seen_list[x, y];
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   695
end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   696
3242
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   697
function is_x_edge(x, y: LongInt): Boolean;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   698
begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   699
if (x < 0) or (x > num_edges_x) or (y < 0) or (y > num_cells_y) then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   700
    is_x_edge := false
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   701
else
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   702
    is_x_edge := x_edge_list[x, y];
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   703
end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   704
3242
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   705
function is_y_edge(x, y: LongInt): Boolean;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   706
begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   707
if (x < 0) or (x > num_cells_x) or (y < 0) or (y > num_edges_y) then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   708
    is_y_edge := false
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   709
else
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   710
    is_y_edge := y_edge_list[x, y];
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   711
end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   712
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   713
procedure see_cell;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   714
var dir: direction;
3242
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   715
    tries: LongInt;
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   716
    x, y: LongInt;
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   717
    found_cell: Boolean;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   718
    next_dir_clockwise: Boolean;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   719
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   720
begin
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   721
x := last_cell[current_step].x;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   722
y := last_cell[current_step].y;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   723
seen_list[x, y] := current_step;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   724
case GetRandom(4) of
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   725
    0: dir := DIR_N;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   726
    1: dir := DIR_E;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   727
    2: dir := DIR_S;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   728
    3: dir := DIR_W;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   729
end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   730
tries := 0;
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   731
found_cell := false;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   732
if getrandom(2) = 1 then next_dir_clockwise := true
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   733
else next_dir_clockwise := false;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   734
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   735
while (tries < 5) and not found_cell do
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   736
begin
3365
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
   737
    if when_seen(x + dir.x, y + dir.y) = current_step then //we are seeing ourselves, try another direction
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   738
    begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   739
        //we have already seen the target cell, decide if we should remove the wall anyway
3365
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
   740
        //(or put a wall there if maze_inverted, but we are not doing that right now)
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   741
        if not maze_inverted and (GetRandom(braidness) = 0) then
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   742
        //or just warn that inverted+braid+indestructible terrain != good idea
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   743
        begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   744
            case dir.x of
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   745
                -1: if x > 0 then ywalls[x-1, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   746
                1: if x < seen_cells_x - 1 then ywalls[x, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   747
            end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   748
            case dir.y of
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   749
                -1: if y > 0 then xwalls[x, y-1] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   750
                1: if y < seen_cells_y - 1 then xwalls[x, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   751
            end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   752
        end;
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   753
        if next_dir_clockwise then
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   754
        begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   755
            if dir = DIR_N then
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   756
                dir := DIR_E
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   757
            else if dir = DIR_E then
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   758
                dir := DIR_S
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   759
            else if dir = DIR_S then
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   760
                dir := DIR_W
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   761
            else
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   762
                dir := DIR_N;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   763
        end
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   764
        else
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   765
        begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   766
            if dir = DIR_N then
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   767
                dir := DIR_W
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   768
            else if dir = DIR_E then
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   769
                dir := DIR_N
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   770
            else if dir = DIR_S then
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   771
                dir := DIR_E
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   772
            else
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   773
                dir := DIR_S;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   774
        end
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   775
    end
3365
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
   776
    else if when_seen(x + dir.x, y + dir.y) = -1 then //cell was not seen yet, go there
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   777
    begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   778
        case dir.y of
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   779
            -1: xwalls[x, y-1] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   780
            1: xwalls[x, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   781
        end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   782
        case dir.x of
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   783
            -1: ywalls[x-1, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   784
            1: ywalls[x, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   785
        end;
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   786
        last_cell[current_step].x := x+dir.x;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   787
        last_cell[current_step].y := y+dir.y;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   788
        came_from_pos[current_step] := came_from_pos[current_step] + 1;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   789
        came_from[current_step, came_from_pos[current_step]].x := x;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   790
        came_from[current_step, came_from_pos[current_step]].y := y;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   791
        found_cell := true;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   792
    end
3365
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
   793
    else //we are seeing someone else, quit
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   794
    begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   795
        step_done[current_step] := true;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   796
        found_cell := true;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   797
    end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   798
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   799
    tries := tries + 1;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   800
end;
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   801
if not found_cell then
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   802
begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   803
    last_cell[current_step].x := came_from[current_step, came_from_pos[current_step]].x;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   804
    last_cell[current_step].y := came_from[current_step, came_from_pos[current_step]].y;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   805
    came_from_pos[current_step] := came_from_pos[current_step] - 1;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   806
    if came_from_pos[current_step] >= 0 then see_cell
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   807
    else step_done[current_step] := true;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   808
end;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   809
end;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   810
3242
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   811
procedure add_vertex(x, y: LongInt);
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   812
var tmp_x, tmp_y: LongInt;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   813
begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   814
if x = NTPX then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   815
begin
3138
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   816
    if pa.ar[num_vertices - 6].x = NTPX then
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   817
    begin
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   818
        num_vertices := num_vertices - 6;
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   819
    end
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   820
    else
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   821
    begin
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   822
        pa.ar[num_vertices].x := NTPX;
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   823
        pa.ar[num_vertices].y := 0;
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   824
    end
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   825
end
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   826
else
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   827
begin
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   828
    if maze_inverted or (x mod 2 = 0) then tmp_x := cellsize
3138
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   829
    else tmp_x := cellsize * 2 div 3;
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   830
    if maze_inverted or (y mod 2 = 0) then tmp_y := cellsize
3138
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   831
    else tmp_y := cellsize * 2 div 3;
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   832
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   833
    pa.ar[num_vertices].x := (x-1)*cellsize + tmp_x;
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   834
    pa.ar[num_vertices].y := (y-1)*cellsize + tmp_y + off_y;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   835
end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   836
num_vertices := num_vertices + 1;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   837
end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   838
3242
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   839
procedure add_edge(x, y: LongInt; dir: direction);
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   840
var i: LongInt;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   841
begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   842
if dir = DIR_N then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   843
begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   844
    dir := DIR_W
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   845
end
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   846
else if dir = DIR_E then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   847
begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   848
    dir := DIR_N
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   849
end
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   850
else if dir = DIR_S then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   851
begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   852
    dir := DIR_E
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   853
end
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   854
else
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   855
begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   856
    dir := DIR_S;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   857
end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   858
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   859
for i := 0 to 3 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   860
begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   861
        if dir = DIR_N then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   862
            dir := DIR_E
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   863
        else if dir = DIR_E then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   864
            dir := DIR_S
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   865
        else if dir = DIR_S then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   866
            dir := DIR_W
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   867
        else
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   868
            dir := DIR_N;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   869
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   870
    if (dir = DIR_N) and is_x_edge(x, y) then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   871
        begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   872
            x_edge_list[x, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   873
            add_vertex(x+1, y);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   874
            add_edge(x, y-1, DIR_N);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   875
            break;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   876
        end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   877
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   878
    if (dir = DIR_E) and is_y_edge(x+1, y) then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   879
        begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   880
            y_edge_list[x+1, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   881
            add_vertex(x+2, y+1);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   882
            add_edge(x+1, y, DIR_E);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   883
            break;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   884
        end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   885
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   886
    if (dir = DIR_S) and is_x_edge(x, y+1) then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   887
        begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   888
            x_edge_list[x, y+1] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   889
            add_vertex(x+1, y+2);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   890
            add_edge(x, y+1, DIR_S);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   891
            break;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   892
        end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   893
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   894
    if (dir = DIR_W) and is_y_edge(x, y) then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   895
        begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   896
            y_edge_list[x, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   897
            add_vertex(x, y+1);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   898
            add_edge(x-1, y, DIR_W);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   899
            break;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   900
        end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   901
end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   902
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   903
end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   904
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   905
begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   906
case cMazeSize of
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   907
    0: begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   908
        cellsize := small_cell_size;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   909
        maze_inverted := false;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   910
    end;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   911
    1: begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   912
        cellsize := medium_cell_size;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   913
        maze_inverted := false;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   914
    end;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   915
    2: begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   916
        cellsize := large_cell_size;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   917
        maze_inverted := false;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   918
    end;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   919
    3: begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   920
        cellsize := small_cell_size;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   921
        maze_inverted := true;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   922
    end;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   923
    4: begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   924
        cellsize := medium_cell_size;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   925
        maze_inverted := true;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   926
    end;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   927
    5: begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   928
        cellsize := large_cell_size;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   929
        maze_inverted := true;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   930
    end;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   931
end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   932
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   933
num_cells_x := LAND_WIDTH div cellsize;
3228
44a59edc7bac - update russian translation a bit
unc0rr
parents: 3225
diff changeset
   934
if not odd(num_cells_x) then num_cells_x := num_cells_x - 1; //needs to be odd
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   935
num_cells_y := LAND_HEIGHT div cellsize;
3228
44a59edc7bac - update russian translation a bit
unc0rr
parents: 3225
diff changeset
   936
if not odd(num_cells_y) then num_cells_y := num_cells_y - 1;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   937
num_edges_x := num_cells_x - 1;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   938
num_edges_y := num_cells_y - 1;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   939
seen_cells_x := num_cells_x div 2;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   940
seen_cells_y := num_cells_y div 2;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   941
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   942
if maze_inverted then
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   943
    num_steps := 3 //TODO randomize, between 3 and 5?
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   944
else
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   945
    num_steps := 1;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   946
SetLength(step_done, num_steps);
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   947
SetLength(last_cell, num_steps);
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   948
SetLength(came_from_pos, num_steps);
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   949
SetLength(came_from, num_steps, num_cells_x*num_cells_y);
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   950
done := false;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   951
for current_step := 0 to num_steps - 1 do
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   952
    step_done[current_step] := false;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   953
    came_from_pos[current_step] := 0;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   954
current_step := 0;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   955
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   956
SetLength(seen_list, seen_cells_x, seen_cells_y);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   957
SetLength(xwalls, seen_cells_x, seen_cells_y - 1);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   958
SetLength(ywalls, seen_cells_x - 1, seen_cells_y);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   959
SetLength(x_edge_list, num_edges_x, num_cells_y);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   960
SetLength(y_edge_list, num_cells_x, num_edges_y);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   961
SetLength(maze, num_cells_x, num_cells_y);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   962
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   963
num_vertices := 0;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   964
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   965
playHeight := num_cells_y * cellsize;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   966
playWidth := num_cells_x * cellsize;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   967
off_y := LAND_HEIGHT - playHeight;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   968
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   969
for x := 0 to playWidth do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   970
    for y := 0 to off_y - 1 do
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   971
        Land[y, x] := 0;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   972
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   973
for x := 0 to playWidth do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   974
    for y := off_y to LAND_HEIGHT - 1 do
3519
56cbc035b74b rename flags
nemo
parents: 3513
diff changeset
   975
        Land[y, x] := lfBasic;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   976
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   977
for y := 0 to num_cells_y - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   978
    for x := 0 to num_cells_x - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   979
        maze[x, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   980
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   981
for x := 0 to seen_cells_x - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   982
    for y := 0 to seen_cells_y - 2 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   983
        xwalls[x, y] := true;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   984
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   985
for x := 0 to seen_cells_x - 2 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   986
    for y := 0 to seen_cells_y - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   987
        ywalls[x, y] := true;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   988
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   989
for x := 0 to seen_cells_x - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   990
    for y := 0 to seen_cells_y - 1 do
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   991
        seen_list[x, y] := -1;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   992
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   993
for x := 0 to num_edges_x - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   994
    for y := 0 to num_cells_y - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   995
        x_edge_list[x, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   996
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   997
for x := 0 to num_cells_x - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   998
    for y := 0 to num_edges_y - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   999
        y_edge_list[x, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1000
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1001
for current_step := 0 to num_steps-1 do
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1002
begin
3242
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
  1003
    x := GetRandom(seen_cells_x - 1) div LongWord(num_steps);
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1004
    last_cell[current_step].x := x + current_step * seen_cells_x div num_steps;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1005
    last_cell[current_step].y := GetRandom(seen_cells_y);
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1006
end;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1007
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1008
while not done do
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1009
begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1010
    done := true;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1011
    for current_step := 0 to num_steps-1 do
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1012
    begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1013
        if not step_done[current_step] then
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1014
        begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1015
            see_cell;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1016
            done := false;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1017
        end;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1018
    end;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1019
end;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1020
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1021
for x := 0 to seen_cells_x - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1022
    for y := 0 to seen_cells_y - 1 do
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1023
        if seen_list[x, y] > -1 then
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1024
            maze[(x+1)*2-1, (y+1)*2-1] := true;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1025
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1026
for x := 0 to seen_cells_x - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1027
    for y := 0 to seen_cells_y - 2 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1028
        if not xwalls[x, y] then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1029
            maze[x*2 + 1, y*2 + 2] := true;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1030
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1031
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1032
for x := 0 to seen_cells_x - 2 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1033
     for y := 0 to seen_cells_y - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1034
        if not ywalls[x, y] then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1035
            maze[x*2 + 2, y*2 + 1] := true;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1036
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1037
for x := 0 to num_edges_x - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1038
    for y := 0 to num_cells_y - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1039
        if maze[x, y] xor maze[x+1, y] then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1040
            x_edge_list[x, y] := true
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1041
        else
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1042
            x_edge_list[x, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1043
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1044
for x := 0 to num_cells_x - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1045
    for y := 0 to num_edges_y - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1046
        if maze[x, y] xor maze[x, y+1] then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1047
            y_edge_list[x, y] := true
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1048
        else
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1049
            y_edge_list[x, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1050
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1051
for x := 0 to num_edges_x - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1052
    for y := 0 to num_cells_y - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1053
        if x_edge_list[x, y] then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1054
        begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1055
            x_edge_list[x, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1056
            add_vertex(x+1, y+1);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1057
            add_vertex(x+1, y);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1058
            add_edge(x, y-1, DIR_N);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1059
            add_vertex(NTPX, 0);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1060
        end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1061
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1062
pa.count := num_vertices;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1063
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1064
RandomizePoints(pa);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1065
BezierizeEdge(pa, _0_25);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1066
RandomizePoints(pa);
3138
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
  1067
BezierizeEdge(pa, _0_25);
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1068
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1069
DrawEdge(pa, 0);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1070
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1071
if maze_inverted then
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1072
    FillLand(1, 1+off_y)
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1073
else
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1074
begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1075
    x := 0;
3519
56cbc035b74b rename flags
nemo
parents: 3513
diff changeset
  1076
    while Land[cellsize div 2 + cellsize + off_y, x] = lfBasic do
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1077
        x := x + 1;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1078
    while Land[cellsize div 2 + cellsize + off_y, x] = 0 do
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1079
        x := x + 1;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1080
    FillLand(x+1, cellsize div 2 + cellsize + off_y);
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1081
end;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1082
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1083
MaxHedgehogs:= 32;
3141
70d65353bd60 prg adds option to toggle girders in maze, adjusts some frontend strings
nemo
parents: 3138
diff changeset
  1084
if (GameFlags and gfDisableGirders) <> 0 then hasGirders:= false
70d65353bd60 prg adds option to toggle girders in maze, adjusts some frontend strings
nemo
parents: 3138
diff changeset
  1085
else hasGirders := true;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1086
leftX:= 0;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1087
rightX:= playWidth;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1088
topY:= off_y;
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1089
hasBorder := false;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1090
end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1091
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1092
procedure GenLandSurface;
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1093
var tmpsurf: PSDL_Surface;
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1094
begin
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1095
    WriteLnToConsole('Generating land...');
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1096
    case cMapGen of
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1097
        0: GenBlank(EdgeTemplates[SelectTemplate]);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1098
        1: GenMaze;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1099
    end;
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1100
    AddProgress();
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1101
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1102
    tmpsurf:= SDL_CreateRGBSurface(SDL_SWSURFACE, LAND_WIDTH, LAND_HEIGHT, 32, RMask, GMask, BMask, 0);
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1103
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1104
    TryDo(tmpsurf <> nil, 'Error creating pre-land surface', true);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1105
    ColorizeLand(tmpsurf);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1106
    AddOnLandObjects(tmpsurf);
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1107
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1108
    LandSurface2LandPixels(tmpsurf);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1109
    SDL_FreeSurface(tmpsurf);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1110
    AddProgress();
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1111
end;
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1112
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1113
procedure MakeFortsMap;
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1114
var tmpsurf: PSDL_Surface;
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1115
begin
2866
450ca0afcd58 Set 32 hog limit for fort maps
nemo
parents: 2747
diff changeset
  1116
MaxHedgehogs:= 32;
2171
8208946331ba Smaxx refactor of LoadImage to use flags, iphone changes by koda (mostly use of rgba instead of rgb)
nemo
parents: 2163
diff changeset
  1117
// For now, defining a fort is playable area as 3072x1200 - there are no tall forts.  The extra height is to avoid triggering border with current code, also if user turns on a border, it will give a bit more maneuvering room.
1784
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1118
playHeight:= 1200;
2096
356468481e74 set Minefield to 150%, reduce fort distance by 512px
nemo
parents: 1906
diff changeset
  1119
playWidth:= 2560;
1776
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
  1120
leftX:= (LAND_WIDTH - playWidth) div 2;
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
  1121
rightX:= ((playWidth + (LAND_WIDTH - playWidth) div 2) - 1);
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
  1122
topY:= LAND_HEIGHT - playHeight;
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
  1123
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1124
WriteLnToConsole('Generating forts land...');
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1125
2171
8208946331ba Smaxx refactor of LoadImage to use flags, iphone changes by koda (mostly use of rgba instead of rgb)
nemo
parents: 2163
diff changeset
  1126
tmpsurf:= LoadImage(Pathz[ptForts] + '/' + ClansArray[0]^.Teams[0]^.FortName + 'L', ifAlpha or ifCritical or ifTransparent or ifIgnoreCaps);
1784
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1127
BlitImageAndGenerateCollisionInfo(leftX+150, LAND_HEIGHT - tmpsurf^.h, tmpsurf^.w, tmpsurf);
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1128
SDL_FreeSurface(tmpsurf);
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1129
2171
8208946331ba Smaxx refactor of LoadImage to use flags, iphone changes by koda (mostly use of rgba instead of rgb)
nemo
parents: 2163
diff changeset
  1130
tmpsurf:= LoadImage(Pathz[ptForts] + '/' + ClansArray[1]^.Teams[0]^.FortName + 'R', ifAlpha or ifCritical or ifTransparent or ifIgnoreCaps);
1784
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1131
BlitImageAndGenerateCollisionInfo(rightX - 150 - tmpsurf^.w, LAND_HEIGHT - tmpsurf^.h, tmpsurf^.w, tmpsurf);
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1132
SDL_FreeSurface(tmpsurf);
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1133
end;
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1134
1792
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1135
// Hi unC0Rr.
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1136
// This is a function that Tiy assures me would not be good for gameplay.
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1137
// It allows the setting of arbitrary portions of landscape as indestructible, or regular, or even blank.
2154
3d2917be12c3 Change default output to stderr since /tmp doesn't exist under windows and is useless under iphoneos, add a couple of extra parameters
nemo
parents: 2152
diff changeset
  1138
// He said I could add it here only when I swore it would not impact gameplay.  Which, as far as I can tell, is true.
3d2917be12c3 Change default output to stderr since /tmp doesn't exist under windows and is useless under iphoneos, add a couple of extra parameters
nemo
parents: 2152
diff changeset
  1139
// I would just like to play with it with my friends if you do not mind.
1792
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1140
// Can allow for amusing maps.
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1141
procedure LoadMask;
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1142
var tmpsurf: PSDL_Surface;
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1143
    p: PLongwordArray;
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1144
    x, y, cpX, cpY: Longword;
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1145
begin
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1146
    tmpsurf:= LoadImage(Pathz[ptMapCurrent] + '/mask', ifAlpha or ifTransparent or ifIgnoreCaps);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1147
    if (tmpsurf <> nil) and (tmpsurf^.w <= LAND_WIDTH) and (tmpsurf^.h <= LAND_HEIGHT) and (tmpsurf^.format^.BytesPerPixel = 4) then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1148
    begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1149
        cpX:= (LAND_WIDTH - tmpsurf^.w) div 2;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1150
        cpY:= LAND_HEIGHT - tmpsurf^.h;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1151
        if SDL_MustLock(tmpsurf) then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1152
            SDLTry(SDL_LockSurface(tmpsurf) >= 0, true);
2376
ece7b87f1334 Strip trailing spaces
nemo
parents: 2338
diff changeset
  1153
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1154
            p:= tmpsurf^.pixels;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1155
            for y:= 0 to Pred(tmpsurf^.h) do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1156
            begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1157
                for x:= 0 to Pred(tmpsurf^.w) do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1158
                begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1159
                    if ((AMask and p^[x]) = 0) then  // Tiy was having trouble generating transparent black
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1160
                        Land[cpY + y, cpX + x]:= 0
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1161
                    else if p^[x] = (AMask or RMask) then
3519
56cbc035b74b rename flags
nemo
parents: 3513
diff changeset
  1162
                        Land[cpY + y, cpX + x]:= lfIndestructible
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1163
                    else if p^[x] = $FFFFFFFF then
3519
56cbc035b74b rename flags
nemo
parents: 3513
diff changeset
  1164
                        Land[cpY + y, cpX + x]:= lfBasic;
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1165
                end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1166
                p:= @(p^[tmpsurf^.pitch div 4]);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1167
            end;
2243
b4764993f833 additional touch support and nemo's reduced land array size
koda
parents: 2240
diff changeset
  1168
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1169
        if SDL_MustLock(tmpsurf) then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1170
            SDL_UnlockSurface(tmpsurf);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1171
    end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1172
    if (tmpsurf <> nil) then 
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1173
        SDL_FreeSurface(tmpsurf);
3513
f589230fa21b now it's possible to select the scheme file in the ifrontendfix a type about loading an image (iphone file system IS case senstive)
koda
parents: 3509
diff changeset
  1174
    tmpsurf:= nil;
1792
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1175
end;
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1176
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1177
procedure LoadMap;
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1178
var tmpsurf: PSDL_Surface;
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1179
    s: shortstring;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1180
    f: textfile;
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1181
begin
2981
d0471586a616 Fix basketball map and hog cannon.
nemo
parents: 2948
diff changeset
  1182
isMap:= true;
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1183
WriteLnToConsole('Loading land from file...');
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1184
AddProgress;
2171
8208946331ba Smaxx refactor of LoadImage to use flags, iphone changes by koda (mostly use of rgba instead of rgb)
nemo
parents: 2163
diff changeset
  1185
tmpsurf:= LoadImage(Pathz[ptMapCurrent] + '/map', ifAlpha or ifCritical or ifTransparent or ifIgnoreCaps);
1760
55a1edd97911 Fix nemo's large land patch
unc0rr
parents: 1754
diff changeset
  1186
TryDo((tmpsurf^.w <= LAND_WIDTH) and (tmpsurf^.h <= LAND_HEIGHT), 'Map dimensions too big!', true);
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1187
2154
3d2917be12c3 Change default output to stderr since /tmp doesn't exist under windows and is useless under iphoneos, add a couple of extra parameters
nemo
parents: 2152
diff changeset
  1188
// unC0Rr - should this be passed from the GUI? I am not sure which layer does what
1792
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1189
s:= Pathz[ptMapCurrent] + '/map.cfg';
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1190
WriteLnToConsole('Fetching map HH limit');
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1191
Assign(f, s);
2747
7889a3a9724f Server:
smxx
parents: 2705
diff changeset
  1192
filemode:= 0; // readonly
1792
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1193
Reset(f);
1795
2457fcc0dcd9 - Set bamboo plinko hedgehogs limit to 48
unc0rr
parents: 1792
diff changeset
  1194
Readln(f);
2457fcc0dcd9 - Set bamboo plinko hedgehogs limit to 48
unc0rr
parents: 1792
diff changeset
  1195
if not eof(f) then Readln(f, MaxHedgehogs);
2457fcc0dcd9 - Set bamboo plinko hedgehogs limit to 48
unc0rr
parents: 1792
diff changeset
  1196
2705
2b5625c4ec16 fix a nasty 196 bytes memory leak in engine, plus other stuff for iphone frontend
koda
parents: 2699
diff changeset
  1197
if (MaxHedgehogs = 0) then MaxHedgehogs:= 18;
1792
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1198
1776
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
  1199
playHeight:= tmpsurf^.h;
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
  1200
playWidth:= tmpsurf^.w;
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
  1201
leftX:= (LAND_WIDTH - playWidth) div 2;
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
  1202
rightX:= (playWidth + ((LAND_WIDTH - playWidth) div 2)) - 1;
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
  1203
topY:= LAND_HEIGHT - playHeight;
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
  1204
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1205
TryDo(tmpsurf^.format^.BytesPerPixel = 4, 'Map should be 32bit', true);
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1206
1772
0fe436fb5f81 Allow loading maps and forts
unc0rr
parents: 1768
diff changeset
  1207
BlitImageAndGenerateCollisionInfo(
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1208
    (LAND_WIDTH - tmpsurf^.w) div 2,
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1209
    LAND_HEIGHT - tmpsurf^.h,
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1210
    tmpsurf^.w,
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1211
    tmpsurf);
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1212
SDL_FreeSurface(tmpsurf);
1792
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1213
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1214
LoadMask;
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1215
end;
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1216
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1217
procedure GenMap;
1784
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1218
var x, y, w, c: Longword;
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1219
begin
3463
23c50be687a9 update sdl functions to latest revision
koda
parents: 3407
diff changeset
  1220
    hasBorder:= false;
2891
e1f902eb0cfe Formerly "Draw Girders" by MrMfS - now "Disable Girders" to allow template prefs to still exist
nemo
parents: 2866
diff changeset
  1221
3463
23c50be687a9 update sdl functions to latest revision
koda
parents: 3407
diff changeset
  1222
    LoadThemeConfig;
23c50be687a9 update sdl functions to latest revision
koda
parents: 3407
diff changeset
  1223
    isMap:= false;
3551
d4de36b3801a moar zoom, fixed fort mode, other glitches
koda
parents: 3526
diff changeset
  1224
    
d4de36b3801a moar zoom, fixed fort mode, other glitches
koda
parents: 3526
diff changeset
  1225
    if ((GameFlags and gfForts) <> 0) or (Pathz[ptMapCurrent] <> '') then
d4de36b3801a moar zoom, fixed fort mode, other glitches
koda
parents: 3526
diff changeset
  1226
        FillChar(Land,SizeOf(TCollisionArray),0);
d4de36b3801a moar zoom, fixed fort mode, other glitches
koda
parents: 3526
diff changeset
  1227
        
3463
23c50be687a9 update sdl functions to latest revision
koda
parents: 3407
diff changeset
  1228
    if (GameFlags and gfForts) = 0 then
23c50be687a9 update sdl functions to latest revision
koda
parents: 3407
diff changeset
  1229
        if Pathz[ptMapCurrent] <> '' then
23c50be687a9 update sdl functions to latest revision
koda
parents: 3407
diff changeset
  1230
            LoadMap
23c50be687a9 update sdl functions to latest revision
koda
parents: 3407
diff changeset
  1231
        else
23c50be687a9 update sdl functions to latest revision
koda
parents: 3407
diff changeset
  1232
            GenLandSurface
23c50be687a9 update sdl functions to latest revision
koda
parents: 3407
diff changeset
  1233
    else
23c50be687a9 update sdl functions to latest revision
koda
parents: 3407
diff changeset
  1234
        MakeFortsMap;
23c50be687a9 update sdl functions to latest revision
koda
parents: 3407
diff changeset
  1235
23c50be687a9 update sdl functions to latest revision
koda
parents: 3407
diff changeset
  1236
    AddProgress;
1760
55a1edd97911 Fix nemo's large land patch
unc0rr
parents: 1754
diff changeset
  1237
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1238
{$IFDEF DEBUGFILE}LogLandDigest;{$ENDIF}
1753
2ccba26f1aa4 Apply nemo's world resize patch
unc0rr
parents: 1738
diff changeset
  1239
1768
9f83102b11ca That was wrong place for the patch
unc0rr
parents: 1767
diff changeset
  1240
// check for land near top
1784
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1241
c:= 0;
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1242
if (GameFlags and gfBorder) <> 0 then
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1243
    hasBorder:= true
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1244
else
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1245
    for y:= topY to topY + 5 do
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1246
        for x:= leftX to rightX do
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1247
            if Land[y, x] <> 0 then
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1248
                begin
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1249
                inc(c);
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1250
                if c > 200 then // avoid accidental triggering
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1251
                    begin
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1252
                    hasBorder:= true;
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1253
                    break;
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1254
                    end;
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1255
                end;
1768
9f83102b11ca That was wrong place for the patch
unc0rr
parents: 1767
diff changeset
  1256
1776
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
  1257
if hasBorder then
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1258
    begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1259
    for y:= 0 to LAND_HEIGHT - 1 do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1260
        for x:= 0 to LAND_WIDTH - 1 do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1261
            if (y < topY) or (x < leftX) or (x > rightX) then
3519
56cbc035b74b rename flags
nemo
parents: 3513
diff changeset
  1262
                Land[y, x]:= lfIndestructible;
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1263
    // experiment hardcoding cave
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1264
    // also try basing cave dimensions on map/template dimensions, if they exist
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1265
    for w:= 0 to 5 do // width of 3 allowed hogs to be knocked through with grenade
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1266
        begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1267
        for y:= topY to LAND_HEIGHT - 1 do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1268
            begin
3595
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1269
                Land[y, leftX + w]:= lfIndestructible;
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1270
                Land[y, rightX - w]:= lfIndestructible;
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1271
                if (y + w) mod 32 < 16 then
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1272
                    c:= AMask
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1273
                else
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1274
                    c:= AMask or RMask or GMask; // FF00FFFF
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1275
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1276
                if (cReducedQuality and rqBlurryLand) = 0 then
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1277
                begin
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1278
                    LandPixels[y, leftX + w]:= c;
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1279
                    LandPixels[y, rightX - w]:= c;
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1280
                end
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1281
                else
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1282
                begin
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1283
                    LandPixels[y div 2, (leftX + w) div 2]:= c;
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1284
                    LandPixels[y div 2, (rightX - w) div 2]:= c;
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1285
                end;
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1286
            end;
1768
9f83102b11ca That was wrong place for the patch
unc0rr
parents: 1767
diff changeset
  1287
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1288
        for x:= leftX to rightX do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1289
            begin
3595
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1290
                Land[topY + w, x]:= lfIndestructible;
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1291
                if (x + w) mod 32 < 16 then
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1292
                    c:= AMask
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1293
                else
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1294
                    c:= AMask or RMask or GMask; // FF00FFFF
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1295
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1296
                if (cReducedQuality and rqBlurryLand) = 0 then
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1297
                    LandPixels[topY + w, x]:= c
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1298
                else
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents: 3551
diff changeset
  1299
                    LandPixels[(topY + w) div 2, x div 2]:= c;
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1300
            end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1301
        end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1302
    end;
1768
9f83102b11ca That was wrong place for the patch
unc0rr
parents: 1767
diff changeset
  1303
2891
e1f902eb0cfe Formerly "Draw Girders" by MrMfS - now "Disable Girders" to allow template prefs to still exist
nemo
parents: 2866
diff changeset
  1304
if (GameFlags and gfDisableGirders) <> 0 then hasGirders:= false;
e1f902eb0cfe Formerly "Draw Girders" by MrMfS - now "Disable Girders" to allow template prefs to still exist
nemo
parents: 2866
diff changeset
  1305
3287
4f7b57ed18b6 New game scheme option to turn off land objects
nemo
parents: 3242
diff changeset
  1306
if ((GameFlags and gfForts) = 0)
4f7b57ed18b6 New game scheme option to turn off land objects
nemo
parents: 3242
diff changeset
  1307
    and ((GameFlags and gfDisableLandObjects) = 0)
4f7b57ed18b6 New game scheme option to turn off land objects
nemo
parents: 3242
diff changeset
  1308
    and (Pathz[ptMapCurrent] = '')
4f7b57ed18b6 New game scheme option to turn off land objects
nemo
parents: 3242
diff changeset
  1309
    then AddObjects;
1776
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
  1310
3058
2ebc20485344 Engine:
smxx
parents: 3055
diff changeset
  1311
FreeLandObjects;
2ebc20485344 Engine:
smxx
parents: 3055
diff changeset
  1312
1807
795f97007833 Split land texture into small ones:
unc0rr
parents: 1806
diff changeset
  1313
UpdateLandTexture(0, LAND_WIDTH, 0, LAND_HEIGHT);
37
2b7f2a43b999 - Properly get seed in net game
unc0rr
parents: 35
diff changeset
  1314
end;
2b7f2a43b999 - Properly get seed in net game
unc0rr
parents: 35
diff changeset
  1315
566
1c1cb593cb81 Save some memory
unc0rr
parents: 561
diff changeset
  1316
function GenPreview: TPreview;
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
  1317
var x, y, xx, yy, t, bit: LongInt;
566
1c1cb593cb81 Save some memory
unc0rr
parents: 561
diff changeset
  1318
    Preview: TPreview;
155
401f4ea24715 Engine can generate land preview and send it via IPC
unc0rr
parents: 109
diff changeset
  1319
begin
3365
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1320
    WriteLnToConsole('Generating preview...');
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1321
    case cMapGen of
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1322
        0: GenBlank(EdgeTemplates[SelectTemplate]);
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1323
        1: GenMaze;
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1324
    end;
155
401f4ea24715 Engine can generate land preview and send it via IPC
unc0rr
parents: 109
diff changeset
  1325
3365
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1326
    for y:= 0 to 127 do
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1327
        for x:= 0 to 31 do
155
401f4ea24715 Engine can generate land preview and send it via IPC
unc0rr
parents: 109
diff changeset
  1328
        begin
3365
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1329
            Preview[y, x]:= 0;
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1330
            for bit:= 0 to 7 do
155
401f4ea24715 Engine can generate land preview and send it via IPC
unc0rr
parents: 109
diff changeset
  1331
            begin
3365
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1332
                t:= 0;
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1333
                for yy:= y * (LAND_HEIGHT div 128) to y * (LAND_HEIGHT div 128) + 7 do
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1334
                    for xx:= x * (LAND_WIDTH div 32) + bit * 8 to x * (LAND_WIDTH div 32) + bit * 8 + 7 do
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1335
                        if Land[yy, xx] <> 0 then inc(t);
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1336
                if t > 8 then
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1337
                    Preview[y, x]:= Preview[y, x] or ($80 shr bit);
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1338
            end;
566
1c1cb593cb81 Save some memory
unc0rr
parents: 561
diff changeset
  1339
        end;
3365
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1340
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1341
    GenPreview:= Preview
155
401f4ea24715 Engine can generate land preview and send it via IPC
unc0rr
parents: 109
diff changeset
  1342
end;
401f4ea24715 Engine can generate land preview and send it via IPC
unc0rr
parents: 109
diff changeset
  1343
3038
4e48c276a468 In pascal unit is a namespace
unc0rr
parents: 3017
diff changeset
  1344
procedure initModule;
2699
249adefa9c1c replace initialization/finalization statements with custom init functions
koda
parents: 2692
diff changeset
  1345
begin
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1346
    LandBackSurface:= nil;
3369
c7289e42f0ee add other controls for map preview, also fix a bug in digest
koda
parents: 3365
diff changeset
  1347
    digest:= '';
3055
f542a36ef6c0 fix a build error on 10.5, LandPixels properly initialized
koda
parents: 3048
diff changeset
  1348
    FillChar(LandPixels, sizeof(TLandArray), 0);
2699
249adefa9c1c replace initialization/finalization statements with custom init functions
koda
parents: 2692
diff changeset
  1349
end;
51
b6e3ae05857f - Get rid of hwserv and runhelper
unc0rr
parents: 37
diff changeset
  1350
3038
4e48c276a468 In pascal unit is a namespace
unc0rr
parents: 3017
diff changeset
  1351
procedure freeModule;
2699
249adefa9c1c replace initialization/finalization statements with custom init functions
koda
parents: 2692
diff changeset
  1352
begin
3055
f542a36ef6c0 fix a build error on 10.5, LandPixels properly initialized
koda
parents: 3048
diff changeset
  1353
2699
249adefa9c1c replace initialization/finalization statements with custom init functions
koda
parents: 2692
diff changeset
  1354
end;
249adefa9c1c replace initialization/finalization statements with custom init functions
koda
parents: 2692
diff changeset
  1355
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
  1356
end.