hedgewars/uLand.pas
author Xeli
Sat, 12 Nov 2011 17:06:49 +0100
branchhedgeroid
changeset 6328 d14adf1c7721
parent 6224 42b256eca362
parent 6313 12567f6f6f02
child 6453 11c578d30bd3
permissions -rw-r--r--
merge...i think
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
4976
088d40d8aba2 Happy 2011 :)
koda
parents: 4900
diff changeset
     3
 * Copyright (c) 2004-2011 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
4367
f4a0ec067601 uLand isn't that important to them
unc0rr
parents: 4359
diff changeset
    23
uses SDLh, uLandTemplates, uFloat, uConsts, GLunit, uTypes;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    24
3242
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
    25
type direction = record x, y: LongInt; end;
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
    26
const DIR_N: direction = (x: 0; y: -1);
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
    27
    DIR_E: direction = (x: 1; y: 0);
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
    28
    DIR_S: direction = (x: 0; y: 1);
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
    29
    DIR_W: direction = (x: -1; y: 0);
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
    30
3038
4e48c276a468 In pascal unit is a namespace
unc0rr
parents: 3017
diff changeset
    31
procedure initModule;
4e48c276a468 In pascal unit is a namespace
unc0rr
parents: 3017
diff changeset
    32
procedure freeModule;
5717
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
    33
procedure DrawBottomBorder;
37
2b7f2a43b999 - Properly get seed in net game
unc0rr
parents: 35
diff changeset
    34
procedure GenMap;
766
cdc8f75ab7bc - Update land texture after explosions
unc0rr
parents: 760
diff changeset
    35
function  GenPreview: TPreview;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    36
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    37
implementation
4389
d1c65b60cd68 Move land hash checking into commands
unc0rr
parents: 4377
diff changeset
    38
uses uConsole, uStore, uRandom, uLandObjects, uIO, uLandTexture, sysutils,
6303
3edb3c857995 Add missing grayscale conversions
nemo
parents: 6254
diff changeset
    39
     uVariables, uUtils, uCommands, Adler32, uDebug, uLandPainted, uTextures;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    40
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
    41
operator=(const a, b: direction) c: Boolean;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
    42
begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
    43
    c := (a.x = b.x) and (a.y = b.y);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
    44
end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
    45
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    46
type TPixAr = record
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    47
              Count: Longword;
22
517be8dc5b76 - Fixed spawning boxes under water
unc0rr
parents: 10
diff changeset
    48
              ar: array[0..Pred(cMaxEdgePoints)] of TPoint;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    49
              end;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
    50
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
    51
procedure DrawLine(X1, Y1, X2, Y2: LongInt; Color: Longword);
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    52
var
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
    53
  eX, eY, dX, dY: LongInt;
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
    54
  i, sX, sY, x, y, d: LongInt;
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    55
begin
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    56
eX:= 0;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    57
eY:= 0;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    58
dX:= X2 - X1;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    59
dY:= Y2 - Y1;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    60
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    61
if (dX > 0) then sX:= 1
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    62
else
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    63
  if (dX < 0) then
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    64
     begin
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    65
     sX:= -1;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    66
     dX:= -dX
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    67
     end else sX:= dX;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    68
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    69
if (dY > 0) then sY:= 1
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    70
  else
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    71
  if (dY < 0) then
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    72
     begin
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    73
     sY:= -1;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    74
     dY:= -dY
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    75
     end else sY:= dY;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    76
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    77
if (dX > dY) then d:= dX
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    78
             else d:= dY;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    79
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    80
x:= X1;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    81
y:= Y1;
2376
ece7b87f1334 Strip trailing spaces
nemo
parents: 2338
diff changeset
    82
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    83
for i:= 0 to d do
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    84
    begin
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    85
    inc(eX, dX);
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    86
    inc(eY, dY);
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    87
    if (eX > d) then
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    88
       begin
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    89
       dec(eX, d);
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    90
       inc(x, sX);
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    91
       end;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    92
    if (eY > d) then
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    93
       begin
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    94
       dec(eY, d);
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    95
       inc(y, sY);
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
    96
       end;
364
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
    97
1753
2ccba26f1aa4 Apply nemo's world resize patch
unc0rr
parents: 1738
diff changeset
    98
    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
    99
       Land[y, x]:= Color;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   100
    end
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   101
end;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   102
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   103
procedure DrawEdge(var pa: TPixAr; Color: Longword);
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   104
var i: LongInt;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   105
begin
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   106
i:= 0;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   107
with pa do
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   108
while i < LongInt(Count) - 1 do
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   109
    if (ar[i + 1].X = NTPX) then inc(i, 2)
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   110
       else begin
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   111
       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
   112
       inc(i)
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   113
       end
22
517be8dc5b76 - Fixed spawning boxes under water
unc0rr
parents: 10
diff changeset
   114
end;
517be8dc5b76 - Fixed spawning boxes under water
unc0rr
parents: 10
diff changeset
   115
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   116
procedure Vector(p1, p2, p3: TPoint; var Vx, Vy: hwFloat);
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   117
var d1, d2, d: hwFloat;
364
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   118
begin
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   119
Vx:= int2hwFloat(p1.X - p3.X);
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   120
Vy:= int2hwFloat(p1.Y - p3.Y);
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   121
d:= DistanceI(p2.X - p1.X, p2.Y - p1.Y);
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   122
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
   123
d2:= Distance(Vx, Vy);
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   124
if d1 < d then d:= d1;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   125
if d2 < d then d:= d2;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   126
d:= d * _1div3;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   127
if d2.QWordValue = 0 then
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   128
   begin
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   129
   Vx:= _0;
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   130
   Vy:= _0
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   131
   end else
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   132
   begin
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   133
   d2:= _1 / d2;
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   134
   Vx:= Vx * d2;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   135
   Vy:= Vy * d2;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   136
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   137
   Vx:= Vx * d;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   138
   Vy:= Vy * d
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   139
   end
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   140
end;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   141
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   142
procedure AddLoopPoints(var pa, opa: TPixAr; StartI, EndI: LongInt; Delta: hwFloat);
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   143
var i, pi, ni: LongInt;
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   144
    NVx, NVy, PVx, PVy: hwFloat;
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   145
    x1, x2, y1, y2: LongInt;
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   146
    tsq, tcb, t, r1, r2, r3, cx1, cx2, cy1, cy2: hwFloat;
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   147
    X, Y: LongInt;
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   148
begin
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   149
pi:= EndI;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   150
i:= StartI;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   151
ni:= Succ(StartI);
3407
dcc129c4352e Engine:
smxx
parents: 3369
diff changeset
   152
{$HINTS OFF}
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   153
Vector(opa.ar[pi], opa.ar[i], opa.ar[ni], NVx, NVy);
3407
dcc129c4352e Engine:
smxx
parents: 3369
diff changeset
   154
{$HINTS ON}
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   155
repeat
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   156
    inc(pi);
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   157
    if pi > EndI then pi:= StartI;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   158
    inc(i);
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   159
    if i > EndI then i:= StartI;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   160
    inc(ni);
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   161
    if ni > EndI then ni:= StartI;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   162
    PVx:= NVx;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   163
    PVy:= NVy;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   164
    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
   165
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   166
    x1:= opa.ar[pi].x;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   167
    y1:= opa.ar[pi].y;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   168
    x2:= opa.ar[i].x;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   169
    y2:= opa.ar[i].y;
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   170
    cx1:= int2hwFloat(x1) - PVx;
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   171
    cy1:= int2hwFloat(y1) - PVy;
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   172
    cx2:= int2hwFloat(x2) + NVx;
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   173
    cy2:= int2hwFloat(y2) + NVy;
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   174
    t:= _0;
364
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   175
    while t.Round = 0 do
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   176
          begin
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   177
          tsq:= t * t;
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   178
          tcb:= tsq * t;
498
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   179
          r1:= (_1 - t*3 + tsq*3 - tcb);
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   180
          r2:= (     t*3 - tsq*6 + tcb*3);
9c8b385dc9a1 - Get rid of operator := to have GPC support
unc0rr
parents: 495
diff changeset
   181
          r3:= (           tsq*3 - tcb*3);
430
57d05fb13ea7 Small performance optimization
unc0rr
parents: 429
diff changeset
   182
          X:= hwRound(r1 * x1 + r2 * cx1 + r3 * cx2 + tcb * x2);
57d05fb13ea7 Small performance optimization
unc0rr
parents: 429
diff changeset
   183
          Y:= hwRound(r1 * y1 + r2 * cy1 + r3 * cy2 + tcb * y2);
364
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   184
          t:= t + Delta;
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   185
          pa.ar[pa.Count].x:= X;
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   186
          pa.ar[pa.Count].y:= Y;
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   187
          inc(pa.Count);
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   188
          TryDo(pa.Count <= cMaxEdgePoints, 'Edge points overflow', true)
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   189
          end;
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   190
until i = StartI;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   191
pa.ar[pa.Count].x:= opa.ar[StartI].X;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   192
pa.ar[pa.Count].y:= opa.ar[StartI].Y;
364
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   193
inc(pa.Count)
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   194
end;
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   195
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   196
procedure BezierizeEdge(var pa: TPixAr; Delta: hwFloat);
495
62c1c2b4414c - Fix most of the warnings in hwengine
unc0rr
parents: 431
diff changeset
   197
var i, StartLoop: LongInt;
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   198
    opa: TPixAr;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   199
begin
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   200
opa:= pa;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   201
pa.Count:= 0;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   202
i:= 0;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   203
StartLoop:= 0;
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   204
while i < LongInt(opa.Count) do
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   205
    if (opa.ar[i + 1].X = NTPX) then
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   206
       begin
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   207
       AddLoopPoints(pa, opa, StartLoop, i, Delta);
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   208
       inc(i, 2);
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   209
       StartLoop:= i;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   210
       pa.ar[pa.Count].X:= NTPX;
3224
f5f4c611bcac possible map gen desync "fix" -- test please
sheepluva
parents: 3181
diff changeset
   211
       pa.ar[pa.Count].Y:= 0;
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   212
       inc(pa.Count);
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   213
       end else inc(i)
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   214
end;
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   215
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   216
procedure FillLand(x, y: LongInt);
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   217
var Stack: record
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   218
           Count: Longword;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   219
           points: array[0..8192] of record
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   220
                                     xl, xr, y, dir: LongInt;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   221
                                     end
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   222
           end;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   223
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   224
    procedure Push(_xl, _xr, _y, _dir: LongInt);
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   225
    begin
75
d2b737858ff7 - New First Aid powerup
unc0rr
parents: 74
diff changeset
   226
    TryDo(Stack.Count <= 8192, 'FillLand: stack overflow', true);
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   227
    _y:= _y + _dir;
1760
55a1edd97911 Fix nemo's large land patch
unc0rr
parents: 1754
diff changeset
   228
    if (_y < 0) or (_y >= LAND_HEIGHT) then exit;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   229
    with Stack.points[Stack.Count] do
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   230
         begin
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   231
         xl:= _xl;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   232
         xr:= _xr;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   233
         y:= _y;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   234
         dir:= _dir
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   235
         end;
75
d2b737858ff7 - New First Aid powerup
unc0rr
parents: 74
diff changeset
   236
    inc(Stack.Count)
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   237
    end;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   238
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   239
    procedure Pop(var _xl, _xr, _y, _dir: LongInt);
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   240
    begin
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   241
    dec(Stack.Count);
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   242
    with Stack.points[Stack.Count] do
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   243
         begin
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   244
         _xl:= xl;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   245
         _xr:= xr;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   246
         _y:= y;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   247
         _dir:= dir
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   248
         end
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   249
    end;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   250
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   251
var xl, xr, dir: LongInt;
351
29bc9c36ad5f Fixed-point arithmetics in engine.
unc0rr
parents: 316
diff changeset
   252
begin
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   253
Stack.Count:= 0;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   254
xl:= x - 1;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   255
xr:= x;
23
16322d14f068 - Land generator uses templates to generate
unc0rr
parents: 22
diff changeset
   256
Push(xl, xr, y, -1);
16322d14f068 - Land generator uses templates to generate
unc0rr
parents: 22
diff changeset
   257
Push(xl, xr, y,  1);
3407
dcc129c4352e Engine:
smxx
parents: 3369
diff changeset
   258
dir:= 0;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   259
while Stack.Count > 0 do
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   260
      begin
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   261
      Pop(xl, xr, y, dir);
51
b6e3ae05857f - Get rid of hwserv and runhelper
unc0rr
parents: 37
diff changeset
   262
      while (xl > 0) and (Land[y, xl] <> 0) do dec(xl);
1760
55a1edd97911 Fix nemo's large land patch
unc0rr
parents: 1754
diff changeset
   263
      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
   264
      while (xl < xr) do
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   265
            begin
51
b6e3ae05857f - Get rid of hwserv and runhelper
unc0rr
parents: 37
diff changeset
   266
            while (xl <= xr) and (Land[y, xl] = 0) do inc(xl);
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   267
            x:= xl;
51
b6e3ae05857f - Get rid of hwserv and runhelper
unc0rr
parents: 37
diff changeset
   268
            while (xl <= xr) and (Land[y, xl] <> 0) do
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   269
                  begin
51
b6e3ae05857f - Get rid of hwserv and runhelper
unc0rr
parents: 37
diff changeset
   270
                  Land[y, xl]:= 0;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   271
                  inc(xl)
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   272
                  end;
22
517be8dc5b76 - Fixed spawning boxes under water
unc0rr
parents: 10
diff changeset
   273
            if x < xl then
517be8dc5b76 - Fixed spawning boxes under water
unc0rr
parents: 10
diff changeset
   274
               begin
517be8dc5b76 - Fixed spawning boxes under water
unc0rr
parents: 10
diff changeset
   275
               Push(x, Pred(xl), y, dir);
517be8dc5b76 - Fixed spawning boxes under water
unc0rr
parents: 10
diff changeset
   276
               Push(x, Pred(xl), y,-dir);
517be8dc5b76 - Fixed spawning boxes under water
unc0rr
parents: 10
diff changeset
   277
               end;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   278
            end;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   279
      end;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   280
end;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   281
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   282
procedure ColorizeLand(Surface: PSDL_Surface);
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   283
var tmpsurf: PSDL_Surface;
1182
e2e13aa055c1 Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents: 1181
diff changeset
   284
    r, rr: TSDL_Rect;
e2e13aa055c1 Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents: 1181
diff changeset
   285
    x, yd, yu: LongInt;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   286
begin
5238
46ddaf14509d Enable ~/.hedgewars/Data (or platform equivalent) to override/extend pretty much everything in system Data dir. Obviously desyncing can occur, so this is at user's own risk. Should simplify map etc install. Needs testing.
nemo
parents: 5231
diff changeset
   287
    tmpsurf:= LoadImage(UserPathz[ptCurrTheme] + '/LandTex', ifIgnoreCaps);
46ddaf14509d Enable ~/.hedgewars/Data (or platform equivalent) to override/extend pretty much everything in system Data dir. Obviously desyncing can occur, so this is at user's own risk. Should simplify map etc install. Needs testing.
nemo
parents: 5231
diff changeset
   288
    if tmpsurf = nil then tmpsurf:= LoadImage(Pathz[ptCurrTheme] + '/LandTex', ifCritical or ifIgnoreCaps);
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   289
    r.y:= 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   290
    while r.y < LAND_HEIGHT do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   291
    begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   292
        r.x:= 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   293
        while r.x < LAND_WIDTH do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   294
        begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   295
            SDL_UpperBlit(tmpsurf, nil, Surface, @r);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   296
            inc(r.x, tmpsurf^.w)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   297
        end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   298
        inc(r.y, tmpsurf^.h)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   299
    end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   300
    SDL_FreeSurface(tmpsurf);
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   301
3038
4e48c276a468 In pascal unit is a namespace
unc0rr
parents: 3017
diff changeset
   302
    // freed in freeModule() below
5238
46ddaf14509d Enable ~/.hedgewars/Data (or platform equivalent) to override/extend pretty much everything in system Data dir. Obviously desyncing can occur, so this is at user's own risk. Should simplify map etc install. Needs testing.
nemo
parents: 5231
diff changeset
   303
    LandBackSurface:= LoadImage(UserPathz[ptCurrTheme] + '/LandBackTex', ifIgnoreCaps or ifTransparent);
46ddaf14509d Enable ~/.hedgewars/Data (or platform equivalent) to override/extend pretty much everything in system Data dir. Obviously desyncing can occur, so this is at user's own risk. Should simplify map etc install. Needs testing.
nemo
parents: 5231
diff changeset
   304
    if LandBackSurface = nil then LandBackSurface:= LoadImage(Pathz[ptCurrTheme] + '/LandBackTex', ifIgnoreCaps or ifTransparent);
6303
3edb3c857995 Add missing grayscale conversions
nemo
parents: 6254
diff changeset
   305
    if (LandBackSurface <> nil) and cGrayScale then Surface2GrayScale(LandBackSurface);
2647
0e1208e92dfe Smaxx patch with tuning by me:
unc0rr
parents: 2619
diff changeset
   306
5238
46ddaf14509d Enable ~/.hedgewars/Data (or platform equivalent) to override/extend pretty much everything in system Data dir. Obviously desyncing can occur, so this is at user's own risk. Should simplify map etc install. Needs testing.
nemo
parents: 5231
diff changeset
   307
    tmpsurf:= LoadImage(UserPathz[ptCurrTheme] + '/Border', ifIgnoreCaps or ifTransparent);
46ddaf14509d Enable ~/.hedgewars/Data (or platform equivalent) to override/extend pretty much everything in system Data dir. Obviously desyncing can occur, so this is at user's own risk. Should simplify map etc install. Needs testing.
nemo
parents: 5231
diff changeset
   308
    if tmpsurf = nil then tmpsurf:= LoadImage(Pathz[ptCurrTheme] + '/Border', ifCritical or ifIgnoreCaps or ifTransparent);
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   309
    for x:= 0 to LAND_WIDTH - 1 do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   310
    begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   311
        yd:= LAND_HEIGHT - 1;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   312
        repeat
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   313
            while (yd > 0) and (Land[yd, x] =  0) do dec(yd);
2376
ece7b87f1334 Strip trailing spaces
nemo
parents: 2338
diff changeset
   314
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   315
            if (yd < 0) then yd:= 0;
1182
e2e13aa055c1 Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents: 1181
diff changeset
   316
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   317
            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
   318
            dec(yd);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   319
            yu:= yd;
2376
ece7b87f1334 Strip trailing spaces
nemo
parents: 2338
diff changeset
   320
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   321
            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
   322
            while (yu < yd ) and (Land[yu, x] =  0) do inc(yu);
2376
ece7b87f1334 Strip trailing spaces
nemo
parents: 2338
diff changeset
   323
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   324
            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
   325
            begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   326
                rr.x:= x;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   327
                rr.y:= yd - 15;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   328
                r.x:= x mod tmpsurf^.w;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   329
                r.y:= 16;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   330
                r.w:= 1;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   331
                r.h:= 16;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   332
                SDL_UpperBlit(tmpsurf, @r, Surface, @rr);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   333
            end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   334
            if (yu > 0) then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   335
            begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   336
                rr.x:= x;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   337
                rr.y:= yu;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   338
                r.x:= x mod tmpsurf^.w;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   339
                r.y:= 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   340
                r.w:= 1;
4374
bcefeeabaa33 Move some stuff from uMisc to uUtils
unC0Rr
parents: 4368
diff changeset
   341
                r.h:= Min(16, yd - yu + 1);
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   342
                SDL_UpperBlit(tmpsurf, @r, Surface, @rr);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   343
            end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   344
            yd:= yu - 1;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   345
        until yd < 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   346
    end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   347
    SDL_FreeSurface(tmpsurf);
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   348
end;
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   349
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   350
procedure SetPoints(var Template: TEdgeTemplate; var pa: TPixAr);
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   351
var i: LongInt;
22
517be8dc5b76 - Fixed spawning boxes under water
unc0rr
parents: 10
diff changeset
   352
begin
23
16322d14f068 - Land generator uses templates to generate
unc0rr
parents: 22
diff changeset
   353
with Template do
16322d14f068 - Land generator uses templates to generate
unc0rr
parents: 22
diff changeset
   354
     begin
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   355
     pa.Count:= BasePointsCount;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   356
     for i:= 0 to pred(pa.Count) do
23
16322d14f068 - Land generator uses templates to generate
unc0rr
parents: 22
diff changeset
   357
         begin
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   358
         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
   359
         if pa.ar[i].x <> NTPX then
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
   360
            pa.ar[i].x:= pa.ar[i].x + ((LAND_WIDTH - Template.TemplateWidth) div 2);
3407
dcc129c4352e Engine:
smxx
parents: 3369
diff changeset
   361
         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
   362
         end;
1183
540cea859395 Step 4: repair girder rendering (girder is 32bit now)
unc0rr
parents: 1182
diff changeset
   363
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   364
     if canMirror then
360
ab6a94334d6d - Two more templates
unc0rr
parents: 359
diff changeset
   365
        if getrandom(2) = 0 then
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   366
           begin
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   367
           for i:= 0 to pred(BasePointsCount) do
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   368
             if pa.ar[i].x <> NTPX then
1760
55a1edd97911 Fix nemo's large land patch
unc0rr
parents: 1754
diff changeset
   369
               pa.ar[i].x:= LAND_WIDTH - 1 - pa.ar[i].x;
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   370
           for i:= 0 to pred(FillPointsCount) do
1760
55a1edd97911 Fix nemo's large land patch
unc0rr
parents: 1754
diff changeset
   371
               FillPoints^[i].x:= LAND_WIDTH - 1 - FillPoints^[i].x;
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   372
           end;
22
517be8dc5b76 - Fixed spawning boxes under water
unc0rr
parents: 10
diff changeset
   373
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
   374
(*  Experiment in making this option more useful
2376
ece7b87f1334 Strip trailing spaces
nemo
parents: 2338
diff changeset
   375
     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
   376
        (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
   377
           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
   378
           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
   379
               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
   380
               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
   381
               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
   382
                   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
   383
               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
   384
           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
   385
               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
   386
               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
   387
               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
   388
                   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
   389
               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
   390
           end;
2376
ece7b87f1334 Strip trailing spaces
nemo
parents: 2338
diff changeset
   391
     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
   392
*)
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
   393
// 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
   394
     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
   395
           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
   396
           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
   397
               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
   398
               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
   399
               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
   400
                   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
   401
               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
   402
           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
   403
               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
   404
               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
   405
               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
   406
                   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
   407
               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
   408
           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
   409
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
   410
     if (canFlip and (getrandom(2) = 0)) then
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   411
           begin
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   412
           for i:= 0 to pred(BasePointsCount) do
1760
55a1edd97911 Fix nemo's large land patch
unc0rr
parents: 1754
diff changeset
   413
               pa.ar[i].y:= LAND_HEIGHT - 1 - pa.ar[i].y;
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   414
           for i:= 0 to pred(FillPointsCount) do
1760
55a1edd97911 Fix nemo's large land patch
unc0rr
parents: 1754
diff changeset
   415
               FillPoints^[i].y:= LAND_HEIGHT - 1 - FillPoints^[i].y;
358
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   416
           end;
236bbd12d4d9 - New Land Generator
unc0rr
parents: 351
diff changeset
   417
     end
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   418
end;
67
3101306251e5 - 2 more Land templates
unc0rr
parents: 64
diff changeset
   419
561
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   420
function CheckIntersect(V1, V2, V3, V4: TPoint): boolean;
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   421
var c1, c2, dm: LongInt;
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   422
begin
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   423
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
   424
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
   425
if dm = 0 then exit(false);
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   426
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   427
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
   428
if dm > 0 then
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   429
   begin
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   430
   if (c1 < 0) or (c1 > dm) then exit(false);
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   431
   if (c2 < 0) or (c2 > dm) then exit(false)
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   432
   end else
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   433
   begin
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   434
   if (c1 > 0) or (c1 < dm) then exit(false);
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   435
   if (c2 > 0) or (c2 < dm) then exit(false)
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   436
   end;
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   437
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   438
//AddFileLog('1  (' + inttostr(V1.x) + ',' + inttostr(V1.y) + ')x(' + inttostr(V2.x) + ',' + inttostr(V2.y) + ')');
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   439
//AddFileLog('2  (' + inttostr(V3.x) + ',' + inttostr(V3.y) + ')x(' + inttostr(V4.x) + ',' + inttostr(V4.y) + ')');
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   440
CheckIntersect:= true
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   441
end;
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   442
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   443
function CheckSelfIntersect(var pa: TPixAr; ind: Longword): boolean;
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   444
var i: Longword;
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   445
begin
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   446
if (ind <= 0) or (ind >= Pred(pa.Count)) then exit(false);
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   447
for i:= 1 to pa.Count - 3 do
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   448
    if (i <= ind - 1) or (i >= ind + 2) then
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   449
      begin
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   450
      if (i <> ind - 1) and
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   451
         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
   452
      if (i <> ind + 2) and
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   453
         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
   454
      end;
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   455
CheckSelfIntersect:= false
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   456
end;
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   457
429
7f69c7ac2e97 One more land template + some templates tuning
unc0rr
parents: 393
diff changeset
   458
procedure RandomizePoints(var pa: TPixAr);
364
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   459
const cEdge = 55;
561
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   460
      cMinDist = 8;
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   461
var radz: array[0..Pred(cMaxEdgePoints)] of LongInt;
561
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   462
    i, k, dist, px, py: LongInt;
364
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   463
begin
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   464
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
   465
  begin
5d8f4737b6cd another uninitialised value radz[k] for corresponding pa.ar of NTPX
nemo
parents: 3224
diff changeset
   466
  radz[i]:= 0;
364
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   467
  with pa.ar[i] do
365
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   468
    if x <> NTPX then
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   469
      begin
1760
55a1edd97911 Fix nemo's large land patch
unc0rr
parents: 1754
diff changeset
   470
      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
   471
      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
   472
      if radz[i] > 0 then
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   473
        for k:= 0 to Pred(i) do
364
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   474
          begin
429
7f69c7ac2e97 One more land template + some templates tuning
unc0rr
parents: 393
diff changeset
   475
          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
   476
          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
   477
          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
   478
        end
a26cec847dd7 - New land generator feature: islands in the sky
unc0rr
parents: 364
diff changeset
   479
      end;
3225
5d8f4737b6cd another uninitialised value radz[k] for corresponding pa.ar of NTPX
nemo
parents: 3224
diff changeset
   480
  end;
364
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   481
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   482
for i:= 0 to Pred(pa.Count) do
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   483
  with pa.ar[i] do
1753
2ccba26f1aa4 Apply nemo's world resize patch
unc0rr
parents: 1738
diff changeset
   484
    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
   485
      begin
561
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   486
      px:= x;
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   487
      py:= y;
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   488
      x:= x + LongInt(GetRandom(7) - 3) * (radz[i] * 5 div 7) div 3;
561
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   489
      y:= y + LongInt(GetRandom(7) - 3) * (radz[i] * 5 div 7) div 3;
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   490
      if CheckSelfIntersect(pa, i) then
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   491
         begin
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   492
         x:= px;
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   493
         y:= py
19d2d422ff84 Improve land generator
unc0rr
parents: 547
diff changeset
   494
         end;
364
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   495
      end
67
3101306251e5 - 2 more Land templates
unc0rr
parents: 64
diff changeset
   496
end;
3101306251e5 - 2 more Land templates
unc0rr
parents: 64
diff changeset
   497
364
52cb4d6f84b7 - Better land generator
unc0rr
parents: 360
diff changeset
   498
23
16322d14f068 - Land generator uses templates to generate
unc0rr
parents: 22
diff changeset
   499
procedure GenBlank(var Template: TEdgeTemplate);
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   500
var pa: TPixAr;
23
16322d14f068 - Land generator uses templates to generate
unc0rr
parents: 22
diff changeset
   501
    i: Longword;
155
401f4ea24715 Engine can generate land preview and send it via IPC
unc0rr
parents: 109
diff changeset
   502
    y, x: Longword;
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
   503
begin
1773
bc6ad6136675 nemo's template patch (invertion)
unc0rr
parents: 1772
diff changeset
   504
    for y:= 0 to LAND_HEIGHT - 1 do
bc6ad6136675 nemo's template patch (invertion)
unc0rr
parents: 1772
diff changeset
   505
        for x:= 0 to LAND_WIDTH - 1 do
4458
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   506
            Land[y, x]:= lfBasic;
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   507
    {$HINTS OFF}
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   508
    SetPoints(Template, pa);
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   509
    {$HINTS ON}
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   510
    for i:= 1 to Template.BezierizeCount do
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   511
        begin
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   512
        BezierizeEdge(pa, _0_5);
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   513
        RandomizePoints(pa);
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   514
        RandomizePoints(pa)
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   515
        end;
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   516
    for i:= 1 to Template.RandPassesCount do RandomizePoints(pa);
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   517
    BezierizeEdge(pa, _0_1);
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   518
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   519
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   520
    DrawEdge(pa, 0);
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   521
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   522
    with Template do
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   523
        for i:= 0 to pred(FillPointsCount) do
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   524
            with FillPoints^[i] do
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   525
                FillLand(x, y);
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   526
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   527
    DrawEdge(pa, lfBasic);
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   528
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   529
    MaxHedgehogs:= Template.MaxHedgehogs;
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   530
    hasGirders:= Template.hasGirders;
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   531
    playHeight:= Template.TemplateHeight;
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   532
    playWidth:= Template.TemplateWidth;
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   533
    leftX:= ((LAND_WIDTH - playWidth) div 2);
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   534
    rightX:= (playWidth + ((LAND_WIDTH - playWidth) div 2)) - 1;
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   535
    topY:= LAND_HEIGHT - playHeight;
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   536
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   537
    // HACK: force to only cavern even if a cavern map is invertable if cTemplateFilter = 4 ?
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   538
    if (cTemplateFilter = 4) or
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   539
    (Template.canInvert and (getrandom(2) = 0)) or
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   540
        (not Template.canInvert and Template.isNegative) then
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   541
        begin
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   542
        hasBorder:= true;
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   543
        for y:= 0 to LAND_HEIGHT - 1 do
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   544
            for x:= 0 to LAND_WIDTH - 1 do
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   545
                if (y < topY) or (x < leftX) or (x > rightX) then
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   546
                    Land[y, x]:= 0
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   547
                else
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   548
                begin
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   549
                if Land[y, x] = 0 then
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   550
                    Land[y, x]:= lfBasic
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   551
                else if Land[y, x] = lfBasic then
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   552
                    Land[y, x]:= 0;
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   553
                end;
7351e6f1ee28 Halfplement decode/drawing routine
unc0rr
parents: 4403
diff changeset
   554
        end;
23
16322d14f068 - Land generator uses templates to generate
unc0rr
parents: 22
diff changeset
   555
end;
16322d14f068 - Land generator uses templates to generate
unc0rr
parents: 22
diff changeset
   556
4494
9585435e20f7 Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents: 4458
diff changeset
   557
procedure GenDrawnMap;
9585435e20f7 Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents: 4458
diff changeset
   558
begin
9585435e20f7 Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents: 4458
diff changeset
   559
    uLandPainted.Draw;
9585435e20f7 Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents: 4458
diff changeset
   560
4559
194d5a7a3fd4 Report 48 hogs for drawn maps
unc0rr
parents: 4494
diff changeset
   561
    MaxHedgehogs:= 48;
4494
9585435e20f7 Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents: 4458
diff changeset
   562
    hasGirders:= true;
9585435e20f7 Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents: 4458
diff changeset
   563
    playHeight:= 2048;
9585435e20f7 Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents: 4458
diff changeset
   564
    playWidth:= 4096;
9585435e20f7 Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents: 4458
diff changeset
   565
    leftX:= ((LAND_WIDTH - playWidth) div 2);
9585435e20f7 Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents: 4458
diff changeset
   566
    rightX:= (playWidth + ((LAND_WIDTH - playWidth) div 2)) - 1;
9585435e20f7 Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents: 4458
diff changeset
   567
    topY:= LAND_HEIGHT - playHeight;
9585435e20f7 Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents: 4458
diff changeset
   568
end;
9585435e20f7 Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents: 4458
diff changeset
   569
371
731ad6d27bd1 integer -> LongInt
unc0rr
parents: 368
diff changeset
   570
function SelectTemplate: LongInt;
161
d8870bbf960e - AmmoMenu
unc0rr
parents: 160
diff changeset
   571
begin
3612
b50215a8a43d land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents: 3608
diff changeset
   572
    if (cReducedQuality and rqLowRes) <> 0 then
b50215a8a43d land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents: 3608
diff changeset
   573
        SelectTemplate:= SmallTemplates[getrandom(Succ(High(SmallTemplates)))]
b50215a8a43d land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents: 3608
diff changeset
   574
    else
b50215a8a43d land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents: 3608
diff changeset
   575
        case cTemplateFilter of
b50215a8a43d land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents: 3608
diff changeset
   576
        0: SelectTemplate:= getrandom(Succ(High(EdgeTemplates)));
b50215a8a43d land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents: 3608
diff changeset
   577
        1: SelectTemplate:= SmallTemplates[getrandom(Succ(High(SmallTemplates)))];
b50215a8a43d land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents: 3608
diff changeset
   578
        2: SelectTemplate:= MediumTemplates[getrandom(Succ(High(MediumTemplates)))];
b50215a8a43d land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents: 3608
diff changeset
   579
        3: SelectTemplate:= LargeTemplates[getrandom(Succ(High(LargeTemplates)))];
b50215a8a43d land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents: 3608
diff changeset
   580
        4: SelectTemplate:= CavernTemplates[getrandom(Succ(High(CavernTemplates)))];
b50215a8a43d land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents: 3608
diff changeset
   581
        5: SelectTemplate:= WackyTemplates[getrandom(Succ(High(WackyTemplates)))];
b50215a8a43d land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents: 3608
diff changeset
   582
    end;
b50215a8a43d land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents: 3608
diff changeset
   583
b50215a8a43d land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents: 3608
diff changeset
   584
    WriteLnToConsole('Selected template #'+inttostr(SelectTemplate)+' using filter #'+inttostr(cTemplateFilter));
161
d8870bbf960e - AmmoMenu
unc0rr
parents: 160
diff changeset
   585
end;
d8870bbf960e - AmmoMenu
unc0rr
parents: 160
diff changeset
   586
1182
e2e13aa055c1 Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents: 1181
diff changeset
   587
procedure LandSurface2LandPixels(Surface: PSDL_Surface);
e2e13aa055c1 Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents: 1181
diff changeset
   588
var x, y: LongInt;
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   589
    p: PLongwordArray;
1180
e56317fdf78d Start implementing support for 32bit sprites concerned in map generation process.
unc0rr
parents: 1085
diff changeset
   590
begin
1182
e2e13aa055c1 Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents: 1181
diff changeset
   591
TryDo(Surface <> nil, 'Assert (LandSurface <> nil) failed', true);
e2e13aa055c1 Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents: 1181
diff changeset
   592
e2e13aa055c1 Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents: 1181
diff changeset
   593
if SDL_MustLock(Surface) then
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   594
    SDLTry(SDL_LockSurface(Surface) >= 0, true);
1180
e56317fdf78d Start implementing support for 32bit sprites concerned in map generation process.
unc0rr
parents: 1085
diff changeset
   595
1182
e2e13aa055c1 Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents: 1181
diff changeset
   596
p:= Surface^.pixels;
1760
55a1edd97911 Fix nemo's large land patch
unc0rr
parents: 1754
diff changeset
   597
for y:= 0 to LAND_HEIGHT - 1 do
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   598
    begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   599
    for x:= 0 to LAND_WIDTH - 1 do
3598
a8aa06bae895 tiy new overlay graphics
koda
parents: 3595
diff changeset
   600
    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
   601
        if (cReducedQuality and rqBlurryLand) = 0 then
3598
a8aa06bae895 tiy new overlay graphics
koda
parents: 3595
diff changeset
   602
             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
   603
        else
3598
a8aa06bae895 tiy new overlay graphics
koda
parents: 3595
diff changeset
   604
             LandPixels[y div 2, x div 2]:= p^[x] or AMask;
2376
ece7b87f1334 Strip trailing spaces
nemo
parents: 2338
diff changeset
   605
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   606
    p:= @(p^[Surface^.pitch div 4]);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   607
    end;
1180
e56317fdf78d Start implementing support for 32bit sprites concerned in map generation process.
unc0rr
parents: 1085
diff changeset
   608
1182
e2e13aa055c1 Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents: 1181
diff changeset
   609
if SDL_MustLock(Surface) then
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
   610
    SDL_UnlockSurface(Surface);
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
   611
end;
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
   612
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   613
procedure GenMaze;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   614
const small_cell_size = 128;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   615
    medium_cell_size = 192;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   616
    large_cell_size = 256;
3138
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   617
    braidness = 10;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   618
3242
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   619
var x, y: LongInt;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   620
    cellsize: LongInt; //selected by the user in the gui
3242
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   621
    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
   622
    num_edges_x, num_edges_y: LongInt; //number of resulting edges that need to be vertexificated
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   623
    num_cells_x, num_cells_y: LongInt; //actual number of cells, depending on cell size
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   624
    seen_list: array of array of LongInt;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   625
    xwalls: array of array of Boolean;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   626
    ywalls: array of array of Boolean;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   627
    x_edge_list: array of array of Boolean;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   628
    y_edge_list: array of array of Boolean;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   629
    maze: array of array of Boolean;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   630
    pa: TPixAr;
3242
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   631
    num_vertices: LongInt;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   632
    off_y: LongInt;
3242
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   633
    num_steps: LongInt;
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   634
    current_step: LongInt;
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   635
    step_done: array of Boolean;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   636
    done: Boolean;
3242
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   637
    last_cell: array of record x, y: LongInt; end;
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   638
    came_from: array of array of record x, y: LongInt; end;
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   639
    came_from_pos: array of LongInt;
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   640
    maze_inverted: Boolean;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   641
3242
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   642
function when_seen(x: LongInt; y: LongInt): LongInt;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   643
begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   644
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
   645
    when_seen := current_step
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   646
else
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   647
    when_seen := seen_list[x, y];
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   648
end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   649
3242
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   650
function is_x_edge(x, y: LongInt): Boolean;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   651
begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   652
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
   653
    is_x_edge := false
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   654
else
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   655
    is_x_edge := x_edge_list[x, y];
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   656
end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   657
3242
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   658
function is_y_edge(x, y: LongInt): Boolean;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   659
begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   660
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
   661
    is_y_edge := false
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   662
else
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   663
    is_y_edge := y_edge_list[x, y];
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   664
end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   665
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   666
procedure see_cell;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   667
var dir: direction;
3242
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   668
    tries: LongInt;
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   669
    x, y: LongInt;
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   670
    found_cell: Boolean;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   671
    next_dir_clockwise: Boolean;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   672
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   673
begin
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   674
x := last_cell[current_step].x;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   675
y := last_cell[current_step].y;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   676
seen_list[x, y] := current_step;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   677
case GetRandom(4) of
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   678
    0: dir := DIR_N;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   679
    1: dir := DIR_E;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   680
    2: dir := DIR_S;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   681
    3: dir := DIR_W;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   682
end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   683
tries := 0;
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   684
found_cell := false;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   685
if getrandom(2) = 1 then next_dir_clockwise := true
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   686
else next_dir_clockwise := false;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   687
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   688
while (tries < 5) and not found_cell do
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   689
begin
3365
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
   690
    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
   691
    begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   692
        //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
   693
        //(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
   694
        if not maze_inverted and (GetRandom(braidness) = 0) then
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   695
        //or just warn that inverted+braid+indestructible terrain != good idea
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   696
        begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   697
            case dir.x of
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   698
                -1: if x > 0 then ywalls[x-1, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   699
                1: if x < seen_cells_x - 1 then ywalls[x, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   700
            end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   701
            case dir.y of
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   702
                -1: if y > 0 then xwalls[x, y-1] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   703
                1: if y < seen_cells_y - 1 then xwalls[x, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   704
            end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   705
        end;
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   706
        if next_dir_clockwise then
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   707
        begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   708
            if dir = DIR_N then
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   709
                dir := DIR_E
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   710
            else if dir = DIR_E then
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   711
                dir := DIR_S
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   712
            else if dir = DIR_S then
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   713
                dir := DIR_W
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   714
            else
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   715
                dir := DIR_N;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   716
        end
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   717
        else
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   718
        begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   719
            if dir = DIR_N then
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   720
                dir := DIR_W
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   721
            else if dir = DIR_E then
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   722
                dir := DIR_N
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   723
            else if dir = DIR_S then
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   724
                dir := DIR_E
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   725
            else
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   726
                dir := DIR_S;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   727
        end
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   728
    end
3365
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
   729
    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
   730
    begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   731
        case dir.y of
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   732
            -1: xwalls[x, y-1] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   733
            1: xwalls[x, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   734
        end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   735
        case dir.x of
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   736
            -1: ywalls[x-1, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   737
            1: ywalls[x, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   738
        end;
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   739
        last_cell[current_step].x := x+dir.x;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   740
        last_cell[current_step].y := y+dir.y;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   741
        came_from_pos[current_step] := came_from_pos[current_step] + 1;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   742
        came_from[current_step, came_from_pos[current_step]].x := x;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   743
        came_from[current_step, came_from_pos[current_step]].y := y;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   744
        found_cell := true;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   745
    end
3365
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
   746
    else //we are seeing someone else, quit
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   747
    begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   748
        step_done[current_step] := true;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   749
        found_cell := true;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   750
    end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   751
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   752
    tries := tries + 1;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   753
end;
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   754
if not found_cell then
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   755
begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   756
    last_cell[current_step].x := came_from[current_step, came_from_pos[current_step]].x;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   757
    last_cell[current_step].y := came_from[current_step, came_from_pos[current_step]].y;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   758
    came_from_pos[current_step] := came_from_pos[current_step] - 1;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   759
    if came_from_pos[current_step] >= 0 then see_cell
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   760
    else step_done[current_step] := true;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   761
end;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   762
end;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   763
3242
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   764
procedure add_vertex(x, y: LongInt);
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   765
var tmp_x, tmp_y: LongInt;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   766
begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   767
if x = NTPX then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   768
begin
3138
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   769
    if pa.ar[num_vertices - 6].x = NTPX then
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   770
    begin
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   771
        num_vertices := num_vertices - 6;
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   772
    end
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   773
    else
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   774
    begin
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   775
        pa.ar[num_vertices].x := NTPX;
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   776
        pa.ar[num_vertices].y := 0;
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   777
    end
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   778
end
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   779
else
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   780
begin
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   781
    if maze_inverted or (x mod 2 = 0) then tmp_x := cellsize
3138
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   782
    else tmp_x := cellsize * 2 div 3;
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   783
    if maze_inverted or (y mod 2 = 0) then tmp_y := cellsize
3138
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   784
    else tmp_y := cellsize * 2 div 3;
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   785
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   786
    pa.ar[num_vertices].x := (x-1)*cellsize + tmp_x;
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
   787
    pa.ar[num_vertices].y := (y-1)*cellsize + tmp_y + off_y;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   788
end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   789
num_vertices := num_vertices + 1;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   790
end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   791
3242
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   792
procedure add_edge(x, y: LongInt; dir: direction);
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   793
var i: LongInt;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   794
begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   795
if dir = DIR_N then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   796
begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   797
    dir := DIR_W
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   798
end
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   799
else if dir = DIR_E then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   800
begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   801
    dir := DIR_N
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   802
end
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   803
else if dir = DIR_S then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   804
begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   805
    dir := DIR_E
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   806
end
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   807
else
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   808
begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   809
    dir := DIR_S;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   810
end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   811
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   812
for i := 0 to 3 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   813
begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   814
        if dir = DIR_N then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   815
            dir := DIR_E
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   816
        else if dir = DIR_E then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   817
            dir := DIR_S
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   818
        else if dir = DIR_S then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   819
            dir := DIR_W
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   820
        else
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   821
            dir := DIR_N;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   822
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   823
    if (dir = DIR_N) and is_x_edge(x, y) then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   824
        begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   825
            x_edge_list[x, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   826
            add_vertex(x+1, y);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   827
            add_edge(x, y-1, DIR_N);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   828
            break;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   829
        end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   830
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   831
    if (dir = DIR_E) and is_y_edge(x+1, y) then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   832
        begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   833
            y_edge_list[x+1, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   834
            add_vertex(x+2, y+1);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   835
            add_edge(x+1, y, DIR_E);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   836
            break;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   837
        end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   838
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   839
    if (dir = DIR_S) and is_x_edge(x, y+1) then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   840
        begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   841
            x_edge_list[x, y+1] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   842
            add_vertex(x+1, y+2);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   843
            add_edge(x, y+1, DIR_S);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   844
            break;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   845
        end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   846
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   847
    if (dir = DIR_W) and is_y_edge(x, y) then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   848
        begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   849
            y_edge_list[x, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   850
            add_vertex(x, y+1);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   851
            add_edge(x-1, y, DIR_W);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   852
            break;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   853
        end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   854
end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   855
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   856
end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   857
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   858
begin
6313
12567f6f6f02 Make mazes filter use same variable as template filter
nemo
parents: 6303
diff changeset
   859
case cTemplateFilter of
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   860
    0: begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   861
        cellsize := small_cell_size;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   862
        maze_inverted := false;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   863
    end;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   864
    1: begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   865
        cellsize := medium_cell_size;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   866
        maze_inverted := false;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   867
    end;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   868
    2: begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   869
        cellsize := large_cell_size;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   870
        maze_inverted := false;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   871
    end;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   872
    3: begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   873
        cellsize := small_cell_size;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   874
        maze_inverted := true;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   875
    end;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   876
    4: begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   877
        cellsize := medium_cell_size;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   878
        maze_inverted := true;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   879
    end;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   880
    5: begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   881
        cellsize := large_cell_size;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   882
        maze_inverted := true;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   883
    end;
3133
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
num_cells_x := LAND_WIDTH div cellsize;
3228
44a59edc7bac - update russian translation a bit
unc0rr
parents: 3225
diff changeset
   887
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
   888
num_cells_y := LAND_HEIGHT div cellsize;
3228
44a59edc7bac - update russian translation a bit
unc0rr
parents: 3225
diff changeset
   889
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
   890
num_edges_x := num_cells_x - 1;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   891
num_edges_y := num_cells_y - 1;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   892
seen_cells_x := num_cells_x div 2;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   893
seen_cells_y := num_cells_y div 2;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   894
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   895
if maze_inverted then
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   896
    num_steps := 3 //TODO randomize, between 3 and 5?
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   897
else
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   898
    num_steps := 1;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   899
SetLength(step_done, num_steps);
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   900
SetLength(last_cell, num_steps);
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   901
SetLength(came_from_pos, num_steps);
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   902
SetLength(came_from, num_steps, num_cells_x*num_cells_y);
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   903
done := false;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   904
for current_step := 0 to num_steps - 1 do
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   905
    step_done[current_step] := false;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   906
    came_from_pos[current_step] := 0;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   907
current_step := 0;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   908
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   909
SetLength(seen_list, seen_cells_x, seen_cells_y);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   910
SetLength(xwalls, seen_cells_x, seen_cells_y - 1);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   911
SetLength(ywalls, seen_cells_x - 1, seen_cells_y);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   912
SetLength(x_edge_list, num_edges_x, num_cells_y);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   913
SetLength(y_edge_list, num_cells_x, num_edges_y);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   914
SetLength(maze, num_cells_x, num_cells_y);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   915
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   916
num_vertices := 0;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   917
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   918
playHeight := num_cells_y * cellsize;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   919
playWidth := num_cells_x * cellsize;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   920
off_y := LAND_HEIGHT - playHeight;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   921
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   922
for x := 0 to playWidth do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   923
    for y := 0 to off_y - 1 do
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   924
        Land[y, x] := 0;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   925
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   926
for x := 0 to playWidth do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   927
    for y := off_y to LAND_HEIGHT - 1 do
3519
56cbc035b74b rename flags
nemo
parents: 3513
diff changeset
   928
        Land[y, x] := lfBasic;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   929
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   930
for y := 0 to num_cells_y - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   931
    for x := 0 to num_cells_x - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   932
        maze[x, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   933
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   934
for x := 0 to seen_cells_x - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   935
    for y := 0 to seen_cells_y - 2 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   936
        xwalls[x, y] := true;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   937
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   938
for x := 0 to seen_cells_x - 2 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   939
    for y := 0 to seen_cells_y - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   940
        ywalls[x, y] := true;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   941
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   942
for x := 0 to seen_cells_x - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   943
    for y := 0 to seen_cells_y - 1 do
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   944
        seen_list[x, y] := -1;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   945
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   946
for x := 0 to num_edges_x - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   947
    for y := 0 to num_cells_y - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   948
        x_edge_list[x, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   949
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   950
for x := 0 to num_cells_x - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   951
    for y := 0 to num_edges_y - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   952
        y_edge_list[x, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   953
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   954
for current_step := 0 to num_steps-1 do
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   955
begin
3242
d8adb26ea6a9 Suppress warning
nemo
parents: 3239
diff changeset
   956
    x := GetRandom(seen_cells_x - 1) div LongWord(num_steps);
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   957
    last_cell[current_step].x := x + current_step * seen_cells_x div num_steps;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   958
    last_cell[current_step].y := GetRandom(seen_cells_y);
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   959
end;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   960
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   961
while not done do
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   962
begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   963
    done := true;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   964
    for current_step := 0 to num_steps-1 do
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   965
    begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   966
        if not step_done[current_step] then
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   967
        begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   968
            see_cell;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   969
            done := false;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   970
        end;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   971
    end;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   972
end;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   973
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   974
for x := 0 to seen_cells_x - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   975
    for y := 0 to seen_cells_y - 1 do
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
   976
        if seen_list[x, y] > -1 then
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   977
            maze[(x+1)*2-1, (y+1)*2-1] := true;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   978
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   979
for x := 0 to seen_cells_x - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   980
    for y := 0 to seen_cells_y - 2 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   981
        if not xwalls[x, y] then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   982
            maze[x*2 + 1, y*2 + 2] := true;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   983
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
        if not ywalls[x, y] then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   988
            maze[x*2 + 2, y*2 + 1] := true;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   989
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   990
for x := 0 to num_edges_x - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   991
    for y := 0 to num_cells_y - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   992
        if maze[x, y] xor maze[x+1, y] then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   993
            x_edge_list[x, y] := true
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
   994
        else
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
        if maze[x, y] xor maze[x, y+1] then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1000
            y_edge_list[x, y] := true
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1001
        else
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1002
            y_edge_list[x, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1003
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1004
for x := 0 to num_edges_x - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1005
    for y := 0 to num_cells_y - 1 do
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1006
        if x_edge_list[x, y] then
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1007
        begin
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1008
            x_edge_list[x, y] := false;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1009
            add_vertex(x+1, y+1);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1010
            add_vertex(x+1, y);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1011
            add_edge(x, y-1, DIR_N);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1012
            add_vertex(NTPX, 0);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1013
        end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1014
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1015
pa.count := num_vertices;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1016
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1017
RandomizePoints(pa);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1018
BezierizeEdge(pa, _0_25);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1019
RandomizePoints(pa);
3138
1798518e1d73 prg tweaks maze
nemo
parents: 3133
diff changeset
  1020
BezierizeEdge(pa, _0_25);
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1021
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1022
DrawEdge(pa, 0);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1023
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1024
if maze_inverted then
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1025
    FillLand(1, 1+off_y)
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1026
else
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1027
begin
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1028
    x := 0;
3519
56cbc035b74b rename flags
nemo
parents: 3513
diff changeset
  1029
    while Land[cellsize div 2 + cellsize + off_y, x] = lfBasic do
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1030
        x := x + 1;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1031
    while Land[cellsize div 2 + cellsize + off_y, x] = 0 do
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1032
        x := x + 1;
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1033
    FillLand(x+1, cellsize div 2 + cellsize + off_y);
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1034
end;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1035
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1036
MaxHedgehogs:= 32;
3141
70d65353bd60 prg adds option to toggle girders in maze, adjusts some frontend strings
nemo
parents: 3138
diff changeset
  1037
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
  1038
else hasGirders := true;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1039
leftX:= 0;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1040
rightX:= playWidth;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1041
topY:= off_y;
3181
5c350b6c38f4 Engine/Frontend:
smxx
parents: 3165
diff changeset
  1042
hasBorder := false;
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1043
end;
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1044
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1045
procedure GenLandSurface;
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1046
var tmpsurf: PSDL_Surface;
5225
d38211100f4d Experiment in making the land less jagg-y
nemo
parents: 4976
diff changeset
  1047
    x,y: Longword;
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1048
begin
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1049
    WriteLnToConsole('Generating land...');
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1050
    case cMapGen of
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1051
        0: GenBlank(EdgeTemplates[SelectTemplate]);
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1052
        1: GenMaze;
4494
9585435e20f7 Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents: 4458
diff changeset
  1053
        2: GenDrawnMap;
4562
b55f78fd2bf6 - Simplify map container code a bit
unc0rr
parents: 4559
diff changeset
  1054
    else
b55f78fd2bf6 - Simplify map container code a bit
unc0rr
parents: 4559
diff changeset
  1055
        OutError('Unknown mapgen', true);
3133
1ab5f18f4df8 prg's maze generator
nemo
parents: 3058
diff changeset
  1056
    end;
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1057
    AddProgress();
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1058
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1059
    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
  1060
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1061
    TryDo(tmpsurf <> nil, 'Error creating pre-land surface', true);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1062
    ColorizeLand(tmpsurf);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1063
    AddOnLandObjects(tmpsurf);
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1064
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1065
    LandSurface2LandPixels(tmpsurf);
5227
nemo
parents: 5225
diff changeset
  1066
    SDL_FreeSurface(tmpsurf);
5274
941da059472b Avoid desyncing on blurry land
nemo
parents: 5241
diff changeset
  1067
    for x:= leftX+2 to rightX-2 do
941da059472b Avoid desyncing on blurry land
nemo
parents: 5241
diff changeset
  1068
        for y:= topY+2 to LAND_HEIGHT-3 do
941da059472b Avoid desyncing on blurry land
nemo
parents: 5241
diff changeset
  1069
            if (Land[y, x] = 0) and 
941da059472b Avoid desyncing on blurry land
nemo
parents: 5241
diff changeset
  1070
               (((Land[y, x-1] = lfBasic) and ((Land[y+1,x] = lfBasic)) or (Land[y-1,x] = lfBasic)) or
941da059472b Avoid desyncing on blurry land
nemo
parents: 5241
diff changeset
  1071
               ((Land[y, x+1] = lfBasic) and ((Land[y-1,x] = lfBasic) or (Land[y+1,x] = lfBasic)))) then
941da059472b Avoid desyncing on blurry land
nemo
parents: 5241
diff changeset
  1072
            begin
941da059472b Avoid desyncing on blurry land
nemo
parents: 5241
diff changeset
  1073
                if (cReducedQuality and rqBlurryLand) = 0 then
941da059472b Avoid desyncing on blurry land
nemo
parents: 5241
diff changeset
  1074
                    begin
5719
0ed1f543f301 Add buttons for tag team, bottom border, unbreak smoothing
nemo
parents: 5718
diff changeset
  1075
                    if (Land[y, x-1] = lfBasic) and (LandPixels[y, x-1] and AMask <> 0) then LandPixels[y, x]:= LandPixels[y, x-1]
0ed1f543f301 Add buttons for tag team, bottom border, unbreak smoothing
nemo
parents: 5718
diff changeset
  1076
                    else if (Land[y, x+1] = lfBasic) and (LandPixels[y, x+1] and AMask <> 0) then LandPixels[y, x]:= LandPixels[y, x+1]
0ed1f543f301 Add buttons for tag team, bottom border, unbreak smoothing
nemo
parents: 5718
diff changeset
  1077
                    else if (Land[y-1, x] = lfBasic) and (LandPixels[y-1, x] and AMask <> 0) then LandPixels[y, x]:= LandPixels[y-1, x]
0ed1f543f301 Add buttons for tag team, bottom border, unbreak smoothing
nemo
parents: 5718
diff changeset
  1078
                    else if (Land[y+1, x] = lfBasic) and (LandPixels[y+1, x] and AMask <> 0) then LandPixels[y, x]:= LandPixels[y+1, x];
5687
fac606654317 Die speckles, round N. Check that alpha is not basically empty while blending, try to match the damaged land type.
nemo
parents: 5441
diff changeset
  1079
                    if (((LandPixels[y,x] and AMask) shr AShift) > 10) then LandPixels[y,x]:= (LandPixels[y,x] and not AMask) or (128 shl AShift)
5274
941da059472b Avoid desyncing on blurry land
nemo
parents: 5241
diff changeset
  1080
                    end;
941da059472b Avoid desyncing on blurry land
nemo
parents: 5241
diff changeset
  1081
                Land[y,x]:= lfObject
941da059472b Avoid desyncing on blurry land
nemo
parents: 5241
diff changeset
  1082
            end
941da059472b Avoid desyncing on blurry land
nemo
parents: 5241
diff changeset
  1083
            else if (Land[y, x] = 0) and
941da059472b Avoid desyncing on blurry land
nemo
parents: 5241
diff changeset
  1084
                    (((Land[y, x-1] = lfBasic) and (Land[y+1,x-1] = lfBasic) and (Land[y+2,x] = lfBasic)) or
941da059472b Avoid desyncing on blurry land
nemo
parents: 5241
diff changeset
  1085
                    ((Land[y, x-1] = lfBasic) and (Land[y-1,x-1] = lfBasic) and (Land[y-2,x] = lfBasic)) or
941da059472b Avoid desyncing on blurry land
nemo
parents: 5241
diff changeset
  1086
                    ((Land[y, x+1] = lfBasic) and (Land[y+1,x+1] = lfBasic) and (Land[y+2,x] = lfBasic)) or
941da059472b Avoid desyncing on blurry land
nemo
parents: 5241
diff changeset
  1087
                    ((Land[y, x+1] = lfBasic) and (Land[y-1,x+1] = lfBasic) and (Land[y-2,x] = lfBasic)) or
941da059472b Avoid desyncing on blurry land
nemo
parents: 5241
diff changeset
  1088
                    ((Land[y+1, x] = lfBasic) and (Land[y+1,x+1] = lfBasic) and (Land[y,x+2] = lfBasic)) or
941da059472b Avoid desyncing on blurry land
nemo
parents: 5241
diff changeset
  1089
                    ((Land[y-1, x] = lfBasic) and (Land[y-1,x+1] = lfBasic) and (Land[y,x+2] = lfBasic)) or
941da059472b Avoid desyncing on blurry land
nemo
parents: 5241
diff changeset
  1090
                    ((Land[y+1, x] = lfBasic) and (Land[y+1,x-1] = lfBasic) and (Land[y,x-2] = lfBasic)) or
941da059472b Avoid desyncing on blurry land
nemo
parents: 5241
diff changeset
  1091
                    ((Land[y-1, x] = lfBasic) and (Land[y-1,x-1] = lfBasic) and (Land[y,x-2] = lfBasic))) then
941da059472b Avoid desyncing on blurry land
nemo
parents: 5241
diff changeset
  1092
            begin
941da059472b Avoid desyncing on blurry land
nemo
parents: 5241
diff changeset
  1093
                if (cReducedQuality and rqBlurryLand) = 0 then
941da059472b Avoid desyncing on blurry land
nemo
parents: 5241
diff changeset
  1094
                    begin
5719
0ed1f543f301 Add buttons for tag team, bottom border, unbreak smoothing
nemo
parents: 5718
diff changeset
  1095
                    if (Land[y, x-1] = lfBasic) and (LandPixels[y,x-1] and AMask <> 0) then LandPixels[y, x]:= LandPixels[y, x-1]
0ed1f543f301 Add buttons for tag team, bottom border, unbreak smoothing
nemo
parents: 5718
diff changeset
  1096
                    else if (Land[y, x+1] = lfBasic) and (LandPixels[y,x+1] and AMask <> 0) then LandPixels[y, x]:= LandPixels[y, x+1]
0ed1f543f301 Add buttons for tag team, bottom border, unbreak smoothing
nemo
parents: 5718
diff changeset
  1097
                    else if (Land[y+1, x] = lfBasic) and (LandPixels[y+1,x] and AMask <> 0) then LandPixels[y, x]:= LandPixels[y+1, x]
0ed1f543f301 Add buttons for tag team, bottom border, unbreak smoothing
nemo
parents: 5718
diff changeset
  1098
                    else if (Land[y-1, x] = lfBasic) and (LandPixels[y-1,x] and AMask <> 0) then LandPixels[y, x]:= LandPixels[y-1, x];
5687
fac606654317 Die speckles, round N. Check that alpha is not basically empty while blending, try to match the damaged land type.
nemo
parents: 5441
diff changeset
  1099
                    if (((LandPixels[y,x] and AMask) shr AShift) > 10) then LandPixels[y,x]:= (LandPixels[y,x] and not AMask) or (64 shl AShift)
5274
941da059472b Avoid desyncing on blurry land
nemo
parents: 5241
diff changeset
  1100
                    end;
941da059472b Avoid desyncing on blurry land
nemo
parents: 5241
diff changeset
  1101
                Land[y,x]:= lfObject
941da059472b Avoid desyncing on blurry land
nemo
parents: 5241
diff changeset
  1102
            end;
5441
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1103
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1104
    AddProgress();
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1105
end;
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1106
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1107
procedure MakeFortsMap;
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1108
var tmpsurf: PSDL_Surface;
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1109
begin
2866
450ca0afcd58 Set 32 hog limit for fort maps
nemo
parents: 2747
diff changeset
  1110
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
  1111
// 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
  1112
playHeight:= 1200;
2096
356468481e74 set Minefield to 150%, reduce fort distance by 512px
nemo
parents: 1906
diff changeset
  1113
playWidth:= 2560;
1776
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
  1114
leftX:= (LAND_WIDTH - playWidth) div 2;
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
  1115
rightX:= ((playWidth + (LAND_WIDTH - playWidth) div 2) - 1);
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
  1116
topY:= LAND_HEIGHT - playHeight;
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
  1117
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1118
WriteLnToConsole('Generating forts land...');
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1119
5238
46ddaf14509d Enable ~/.hedgewars/Data (or platform equivalent) to override/extend pretty much everything in system Data dir. Obviously desyncing can occur, so this is at user's own risk. Should simplify map etc install. Needs testing.
nemo
parents: 5231
diff changeset
  1120
tmpsurf:= LoadImage(UserPathz[ptForts] + '/' + ClansArray[0]^.Teams[0]^.FortName + 'L', ifAlpha or ifTransparent or ifIgnoreCaps);
46ddaf14509d Enable ~/.hedgewars/Data (or platform equivalent) to override/extend pretty much everything in system Data dir. Obviously desyncing can occur, so this is at user's own risk. Should simplify map etc install. Needs testing.
nemo
parents: 5231
diff changeset
  1121
if tmpsurf = nil then 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
  1122
BlitImageAndGenerateCollisionInfo(leftX+150, LAND_HEIGHT - tmpsurf^.h, tmpsurf^.w, tmpsurf);
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1123
SDL_FreeSurface(tmpsurf);
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1124
5238
46ddaf14509d Enable ~/.hedgewars/Data (or platform equivalent) to override/extend pretty much everything in system Data dir. Obviously desyncing can occur, so this is at user's own risk. Should simplify map etc install. Needs testing.
nemo
parents: 5231
diff changeset
  1125
tmpsurf:= LoadImage(UserPathz[ptForts] + '/' + ClansArray[1]^.Teams[0]^.FortName + 'R', ifAlpha or ifTransparent or ifIgnoreCaps);
46ddaf14509d Enable ~/.hedgewars/Data (or platform equivalent) to override/extend pretty much everything in system Data dir. Obviously desyncing can occur, so this is at user's own risk. Should simplify map etc install. Needs testing.
nemo
parents: 5231
diff changeset
  1126
if tmpsurf = nil then 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
  1127
BlitImageAndGenerateCollisionInfo(rightX - 150 - tmpsurf^.w, 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
end;
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1130
5238
46ddaf14509d Enable ~/.hedgewars/Data (or platform equivalent) to override/extend pretty much everything in system Data dir. Obviously desyncing can occur, so this is at user's own risk. Should simplify map etc install. Needs testing.
nemo
parents: 5231
diff changeset
  1131
// Loads Land[] from an image, allowing overriding standard collision
3920
a54ca6185307 updated lua loading in the ifrontend and also fixed masked maps
koda
parents: 3912
diff changeset
  1132
procedure LoadMask(mapName: shortstring);
1792
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1133
var tmpsurf: PSDL_Surface;
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1134
    p: PLongwordArray;
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1135
    x, y, cpX, cpY: Longword;
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1136
begin
5770
022a18320f01 load mask from user path as well
nemo
parents: 5719
diff changeset
  1137
tmpsurf:= LoadImage(UserPathz[ptMapCurrent] + '/mask', ifAlpha or ifTransparent or ifIgnoreCaps);
022a18320f01 load mask from user path as well
nemo
parents: 5719
diff changeset
  1138
if tmpsurf = nil then tmpsurf:= LoadImage(Pathz[ptMapCurrent] + '/mask', ifAlpha or ifTransparent or ifIgnoreCaps);
022a18320f01 load mask from user path as well
nemo
parents: 5719
diff changeset
  1139
if tmpsurf = nil then
022a18320f01 load mask from user path as well
nemo
parents: 5719
diff changeset
  1140
    begin
022a18320f01 load mask from user path as well
nemo
parents: 5719
diff changeset
  1141
    mapName:= ExtractFileName(Pathz[ptMapCurrent]);
022a18320f01 load mask from user path as well
nemo
parents: 5719
diff changeset
  1142
    tmpsurf:= LoadImage(UserPathz[ptMissionMaps] + '/' + mapName + '/mask', ifAlpha or ifTransparent or ifIgnoreCaps);
5775
49c5a490f230 copy/paste fail
nemo
parents: 5770
diff changeset
  1143
    if tmpsurf = nil then tmpsurf:= LoadImage(Pathz[ptMissionMaps] + '/' + mapName + '/mask', ifAlpha or ifTransparent or ifIgnoreCaps);
5770
022a18320f01 load mask from user path as well
nemo
parents: 5719
diff changeset
  1144
    end;
3920
a54ca6185307 updated lua loading in the ifrontend and also fixed masked maps
koda
parents: 3912
diff changeset
  1145
6096
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1146
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1147
if (tmpsurf <> nil) and (tmpsurf^.w <= LAND_WIDTH) and (tmpsurf^.h <= LAND_HEIGHT) and (tmpsurf^.format^.BytesPerPixel = 4) then
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1148
begin
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1149
    disableLandBack:= true;
2376
ece7b87f1334 Strip trailing spaces
nemo
parents: 2338
diff changeset
  1150
6096
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1151
    cpX:= (LAND_WIDTH - tmpsurf^.w) div 2;
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1152
    cpY:= LAND_HEIGHT - tmpsurf^.h;
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1153
    if SDL_MustLock(tmpsurf) then
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1154
        SDLTry(SDL_LockSurface(tmpsurf) >= 0, true);
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1155
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1156
        p:= tmpsurf^.pixels;
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1157
        for y:= 0 to Pred(tmpsurf^.h) do
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1158
        begin
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1159
            for x:= 0 to Pred(tmpsurf^.w) do
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1160
            begin
6096
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1161
                if ((AMask and p^[x]) = 0) then
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1162
                    Land[cpY + y, cpX + x]:= 0
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1163
                else if p^[x] = $FFFFFFFF then
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1164
                    Land[cpY + y, cpX + x]:= lfObject
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1165
                else if p^[x] = (AMask or RMask) then
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1166
                    Land[cpY + y, cpX + x]:= lfIndestructible
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1167
                else if p^[x] = AMask then
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1168
                    begin
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1169
                    Land[cpY + y, cpX + x]:= lfBasic;
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1170
                    disableLandBack:= false
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1171
                    end
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1172
                else if p^[x] = (AMask or BMask) then
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1173
                    Land[cpY + y, cpX + x]:= lfObject or lfIce
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1174
            end;
6096
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1175
            p:= @(p^[tmpsurf^.pitch div 4]);
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1176
        end;
2243
b4764993f833 additional touch support and nemo's reduced land array size
koda
parents: 2240
diff changeset
  1177
6096
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1178
    if SDL_MustLock(tmpsurf) then
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1179
        SDL_UnlockSurface(tmpsurf);
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1180
    if not disableLandBack then
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1181
        begin
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1182
        // freed in freeModule() below
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1183
        LandBackSurface:= LoadImage(UserPathz[ptCurrTheme] + '/LandBackTex', ifIgnoreCaps or ifTransparent);
6303
3edb3c857995 Add missing grayscale conversions
nemo
parents: 6254
diff changeset
  1184
        if LandBackSurface = nil then LandBackSurface:= LoadImage(Pathz[ptCurrTheme] + '/LandBackTex', ifIgnoreCaps or ifTransparent);
3edb3c857995 Add missing grayscale conversions
nemo
parents: 6254
diff changeset
  1185
        if (LandBackSurface <> nil) and cGrayScale then Surface2GrayScale(LandBackSurface)
6096
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1186
        end;
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1187
end;
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1188
if (tmpsurf <> nil) then
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1189
    SDL_FreeSurface(tmpsurf);
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks.
nemo
parents: 6082
diff changeset
  1190
tmpsurf:= nil;
1792
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1191
end;
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1192
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1193
procedure LoadMap;
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1194
var tmpsurf: PSDL_Surface;
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1195
    s: shortstring;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1196
    f: textfile;
3920
a54ca6185307 updated lua loading in the ifrontend and also fixed masked maps
koda
parents: 3912
diff changeset
  1197
    mapName: shortstring = '';
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1198
begin
2981
d0471586a616 Fix basketball map and hog cannon.
nemo
parents: 2948
diff changeset
  1199
isMap:= true;
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1200
WriteLnToConsole('Loading land from file...');
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1201
AddProgress;
5238
46ddaf14509d Enable ~/.hedgewars/Data (or platform equivalent) to override/extend pretty much everything in system Data dir. Obviously desyncing can occur, so this is at user's own risk. Should simplify map etc install. Needs testing.
nemo
parents: 5231
diff changeset
  1202
tmpsurf:= LoadImage(UserPathz[ptMapCurrent] + '/map', ifAlpha or ifTransparent or ifIgnoreCaps);
46ddaf14509d Enable ~/.hedgewars/Data (or platform equivalent) to override/extend pretty much everything in system Data dir. Obviously desyncing can occur, so this is at user's own risk. Should simplify map etc install. Needs testing.
nemo
parents: 5231
diff changeset
  1203
if tmpsurf = nil then tmpsurf:= LoadImage(Pathz[ptMapCurrent] + '/map', ifAlpha or ifTransparent or ifIgnoreCaps);
3912
e11df2de6af2 have engine try for a second position when map loading fails (in this way it's possible to move Missions data to any path)
koda
parents: 3836
diff changeset
  1204
if tmpsurf = nil then
5770
022a18320f01 load mask from user path as well
nemo
parents: 5719
diff changeset
  1205
    begin
3912
e11df2de6af2 have engine try for a second position when map loading fails (in this way it's possible to move Missions data to any path)
koda
parents: 3836
diff changeset
  1206
    mapName:= ExtractFileName(Pathz[ptMapCurrent]);
5238
46ddaf14509d Enable ~/.hedgewars/Data (or platform equivalent) to override/extend pretty much everything in system Data dir. Obviously desyncing can occur, so this is at user's own risk. Should simplify map etc install. Needs testing.
nemo
parents: 5231
diff changeset
  1207
    tmpsurf:= LoadImage(UserPathz[ptMissionMaps] + '/' + mapName + '/map', ifAlpha or ifTransparent or ifIgnoreCaps);
46ddaf14509d Enable ~/.hedgewars/Data (or platform equivalent) to override/extend pretty much everything in system Data dir. Obviously desyncing can occur, so this is at user's own risk. Should simplify map etc install. Needs testing.
nemo
parents: 5231
diff changeset
  1208
    if tmpsurf = nil then tmpsurf:= LoadImage(Pathz[ptMissionMaps] + '/' + mapName + '/map', ifAlpha or ifCritical or ifTransparent or ifIgnoreCaps);
5770
022a18320f01 load mask from user path as well
nemo
parents: 5719
diff changeset
  1209
    end;
1760
55a1edd97911 Fix nemo's large land patch
unc0rr
parents: 1754
diff changeset
  1210
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
  1211
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
  1212
// unC0Rr - should this be passed from the GUI? I am not sure which layer does what
5241
e1fb0fc971c6 add missing user path check
nemo
parents: 5238
diff changeset
  1213
s:= UserPathz[ptMapCurrent] + '/map.cfg';
e1fb0fc971c6 add missing user path check
nemo
parents: 5238
diff changeset
  1214
if not FileExists(s) then s:= Pathz[ptMapCurrent] + '/map.cfg';
1792
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1215
WriteLnToConsole('Fetching map HH limit');
3912
e11df2de6af2 have engine try for a second position when map loading fails (in this way it's possible to move Missions data to any path)
koda
parents: 3836
diff changeset
  1216
{$I-}
1792
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1217
Assign(f, s);
2747
7889a3a9724f Server:
smxx
parents: 2705
diff changeset
  1218
filemode:= 0; // readonly
1792
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1219
Reset(f);
3912
e11df2de6af2 have engine try for a second position when map loading fails (in this way it's possible to move Missions data to any path)
koda
parents: 3836
diff changeset
  1220
if IOResult <> 0 then
e11df2de6af2 have engine try for a second position when map loading fails (in this way it's possible to move Missions data to any path)
koda
parents: 3836
diff changeset
  1221
begin
e11df2de6af2 have engine try for a second position when map loading fails (in this way it's possible to move Missions data to any path)
koda
parents: 3836
diff changeset
  1222
    s:= Pathz[ptMissionMaps] + '/' + mapName + '/map.cfg';
e11df2de6af2 have engine try for a second position when map loading fails (in this way it's possible to move Missions data to any path)
koda
parents: 3836
diff changeset
  1223
    Assign(f, s);
e11df2de6af2 have engine try for a second position when map loading fails (in this way it's possible to move Missions data to any path)
koda
parents: 3836
diff changeset
  1224
    Reset(f);
e11df2de6af2 have engine try for a second position when map loading fails (in this way it's possible to move Missions data to any path)
koda
parents: 3836
diff changeset
  1225
end;
1795
2457fcc0dcd9 - Set bamboo plinko hedgehogs limit to 48
unc0rr
parents: 1792
diff changeset
  1226
Readln(f);
2457fcc0dcd9 - Set bamboo plinko hedgehogs limit to 48
unc0rr
parents: 1792
diff changeset
  1227
if not eof(f) then Readln(f, MaxHedgehogs);
3912
e11df2de6af2 have engine try for a second position when map loading fails (in this way it's possible to move Missions data to any path)
koda
parents: 3836
diff changeset
  1228
{$I+}
2705
2b5625c4ec16 fix a nasty 196 bytes memory leak in engine, plus other stuff for iphone frontend
koda
parents: 2699
diff changeset
  1229
if (MaxHedgehogs = 0) then MaxHedgehogs:= 18;
1792
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1230
1776
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
  1231
playHeight:= tmpsurf^.h;
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
  1232
playWidth:= tmpsurf^.w;
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
  1233
leftX:= (LAND_WIDTH - playWidth) div 2;
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
  1234
rightX:= (playWidth + ((LAND_WIDTH - playWidth) div 2)) - 1;
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
  1235
topY:= LAND_HEIGHT - playHeight;
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
  1236
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1237
TryDo(tmpsurf^.format^.BytesPerPixel = 4, 'Map should be 32bit', true);
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1238
1772
0fe436fb5f81 Allow loading maps and forts
unc0rr
parents: 1768
diff changeset
  1239
BlitImageAndGenerateCollisionInfo(
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1240
    (LAND_WIDTH - tmpsurf^.w) div 2,
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1241
    LAND_HEIGHT - tmpsurf^.h,
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1242
    tmpsurf^.w,
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1243
    tmpsurf);
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1244
SDL_FreeSurface(tmpsurf);
1792
c30c6944bd49 engine part of nemo's patch
unc0rr
parents: 1784
diff changeset
  1245
3920
a54ca6185307 updated lua loading in the ifrontend and also fixed masked maps
koda
parents: 3912
diff changeset
  1246
LoadMask(mapname);
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1247
end;
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1248
5717
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1249
procedure DrawBottomBorder; // broken out from other borders for doing a floor-only map, or possibly updating bottom during SD
5832
f730c8a9777b Remove some unused variables and options.inc which uFloat doesn't use, probably should never use, and was getting in the way of my testcase - but most importantly, remove the inline on hwSqrt which was causing very bad math on my compiler/machine. We may have to remove more inlining. A pity.
nemo
parents: 5775
diff changeset
  1250
var x, w, c: Longword;
5717
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1251
begin
5718
e74de0528ef4 Let's draw the bottom border thicker, so it is more visible
nemo
parents: 5717
diff changeset
  1252
for w:= 0 to 23 do
5717
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1253
    for x:= leftX to rightX do
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1254
        begin
6011
519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents: 5832
diff changeset
  1255
        Land[Longword(cWaterLine) - 1 - w, x]:= lfIndestructible;
5717
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1256
        if (x + w) mod 32 < 16 then
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1257
            c:= AMask
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1258
        else
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1259
            c:= AMask or RMask or GMask; // FF00FFFF
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1260
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1261
        if (cReducedQuality and rqBlurryLand) = 0 then
6011
519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents: 5832
diff changeset
  1262
            LandPixels[Longword(cWaterLine) - 1 - w, x]:= c
5717
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1263
        else
6011
519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents: 5832
diff changeset
  1264
            LandPixels[(Longword(cWaterLine) - 1 - w) div 2, x div 2]:= c
5718
e74de0528ef4 Let's draw the bottom border thicker, so it is more visible
nemo
parents: 5717
diff changeset
  1265
        end
5717
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1266
end;
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1267
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1268
procedure GenMap;
1784
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1269
var x, y, w, c: Longword;
1754
a37392548124 Some fixes by nemo
unc0rr
parents: 1753
diff changeset
  1270
begin
3463
23c50be687a9 update sdl functions to latest revision
koda
parents: 3407
diff changeset
  1271
    hasBorder:= false;
2891
e1f902eb0cfe Formerly "Draw Girders" by MrMfS - now "Disable Girders" to allow template prefs to still exist
nemo
parents: 2866
diff changeset
  1272
3463
23c50be687a9 update sdl functions to latest revision
koda
parents: 3407
diff changeset
  1273
    LoadThemeConfig;
23c50be687a9 update sdl functions to latest revision
koda
parents: 3407
diff changeset
  1274
    isMap:= false;
3697
d5b30d6373fc remove trailing spaces from end of line
koda
parents: 3632
diff changeset
  1275
4900
8ad0e23e6d63 addfilelog <3 debugfile
koda
parents: 4562
diff changeset
  1276
    // is this not needed any more? lets hope setlength sets also 0s
3630
2c7a9d5aa18c fix static land loading on desktop
koda
parents: 3617
diff changeset
  1277
    //if ((GameFlags and gfForts) <> 0) or (Pathz[ptMapCurrent] <> '') then
2c7a9d5aa18c fix static land loading on desktop
koda
parents: 3617
diff changeset
  1278
    //    FillChar(Land,SizeOf(TCollisionArray),0);*)
3697
d5b30d6373fc remove trailing spaces from end of line
koda
parents: 3632
diff changeset
  1279
3463
23c50be687a9 update sdl functions to latest revision
koda
parents: 3407
diff changeset
  1280
    if (GameFlags and gfForts) = 0 then
23c50be687a9 update sdl functions to latest revision
koda
parents: 3407
diff changeset
  1281
        if Pathz[ptMapCurrent] <> '' then
23c50be687a9 update sdl functions to latest revision
koda
parents: 3407
diff changeset
  1282
            LoadMap
23c50be687a9 update sdl functions to latest revision
koda
parents: 3407
diff changeset
  1283
        else
23c50be687a9 update sdl functions to latest revision
koda
parents: 3407
diff changeset
  1284
            GenLandSurface
23c50be687a9 update sdl functions to latest revision
koda
parents: 3407
diff changeset
  1285
    else
23c50be687a9 update sdl functions to latest revision
koda
parents: 3407
diff changeset
  1286
        MakeFortsMap;
23c50be687a9 update sdl functions to latest revision
koda
parents: 3407
diff changeset
  1287
23c50be687a9 update sdl functions to latest revision
koda
parents: 3407
diff changeset
  1288
    AddProgress;
1760
55a1edd97911 Fix nemo's large land patch
unc0rr
parents: 1754
diff changeset
  1289
1768
9f83102b11ca That was wrong place for the patch
unc0rr
parents: 1767
diff changeset
  1290
// check for land near top
1784
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1291
c:= 0;
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1292
if (GameFlags and gfBorder) <> 0 then
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1293
    hasBorder:= true
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1294
else
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1295
    for y:= topY to topY + 5 do
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1296
        for x:= leftX to rightX do
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1297
            if Land[y, x] <> 0 then
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1298
                begin
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1299
                inc(c);
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1300
                if c > 200 then // avoid accidental triggering
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1301
                    begin
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1302
                    hasBorder:= true;
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1303
                    break;
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1304
                    end;
dfe9bafb4590 Apply nemo's patch polished by me:
unc0rr
parents: 1779
diff changeset
  1305
                end;
1768
9f83102b11ca That was wrong place for the patch
unc0rr
parents: 1767
diff changeset
  1306
1776
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
  1307
if hasBorder then
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1308
    begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1309
    for y:= 0 to LAND_HEIGHT - 1 do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1310
        for x:= 0 to LAND_WIDTH - 1 do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1311
            if (y < topY) or (x < leftX) or (x > rightX) then
3519
56cbc035b74b rename flags
nemo
parents: 3513
diff changeset
  1312
                Land[y, x]:= lfIndestructible;
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1313
    // experiment hardcoding cave
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1314
    // 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
  1315
    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
  1316
        begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1317
        for y:= topY to LAND_HEIGHT - 1 do
5717
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1318
                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
  1319
                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
  1320
                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
  1321
                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
  1322
                    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
  1323
                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
  1324
                    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
  1325
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
  1326
                if (cReducedQuality and rqBlurryLand) = 0 then
5717
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1327
                    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
  1328
                    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
  1329
                    LandPixels[y, rightX - w]:= c;
5717
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1330
                    end
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
  1331
                else
5717
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1332
                    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
  1333
                    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
  1334
                    LandPixels[y div 2, (rightX - w) div 2]:= c;
5717
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1335
                    end;
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
  1336
                end;
1768
9f83102b11ca That was wrong place for the patch
unc0rr
parents: 1767
diff changeset
  1337
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1338
        for x:= leftX to rightX do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1339
            begin
5717
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1340
            Land[topY + w, x]:= lfIndestructible;
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1341
            if (x + w) mod 32 < 16 then
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1342
                c:= AMask
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1343
            else
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1344
                c:= AMask or RMask or GMask; // FF00FFFF
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
  1345
5717
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1346
            if (cReducedQuality and rqBlurryLand) = 0 then
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1347
                LandPixels[topY + w, x]:= c
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1348
            else
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1349
                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
  1350
            end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1351
        end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1352
    end;
1768
9f83102b11ca That was wrong place for the patch
unc0rr
parents: 1767
diff changeset
  1353
5717
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1354
if (GameFlags and gfBottomBorder) <> 0 then DrawBottomBorder;
6d513913b7a9 Add option for a bottom border. Needs testing.
nemo
parents: 5687
diff changeset
  1355
2891
e1f902eb0cfe Formerly "Draw Girders" by MrMfS - now "Disable Girders" to allow template prefs to still exist
nemo
parents: 2866
diff changeset
  1356
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
  1357
3287
4f7b57ed18b6 New game scheme option to turn off land objects
nemo
parents: 3242
diff changeset
  1358
if ((GameFlags and gfForts) = 0)
4f7b57ed18b6 New game scheme option to turn off land objects
nemo
parents: 3242
diff changeset
  1359
    and (Pathz[ptMapCurrent] = '')
3936
0b982d340633 bug #83 - move test of disabled land objects into AddObjects
nemo
parents: 3920
diff changeset
  1360
    then AddObjects
0b982d340633 bug #83 - move test of disabled land objects into AddObjects
nemo
parents: 3920
diff changeset
  1361
else AddProgress();
1776
dd5648e250e4 - nemo's patch for custom cave map dimensions
unc0rr
parents: 1773
diff changeset
  1362
3058
2ebc20485344 Engine:
smxx
parents: 3055
diff changeset
  1363
FreeLandObjects;
2ebc20485344 Engine:
smxx
parents: 3055
diff changeset
  1364
5441
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1365
if cGrayScale then
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1366
    begin
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1367
    if (cReducedQuality and rqBlurryLand) = 0 then
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1368
        for x:= leftX to rightX do
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1369
            for y:= topY to LAND_HEIGHT-1 do
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1370
                begin
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1371
                w:= LandPixels[y,x];
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1372
                w:= round(((w shr RShift and $FF) * RGB_LUMINANCE_RED +
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1373
                      (w shr BShift and $FF) * RGB_LUMINANCE_GREEN +
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1374
                      (w shr GShift and $FF) * RGB_LUMINANCE_BLUE));
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1375
                if w > 255 then w:= 255;
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1376
                w:= (w and $FF shl RShift) or (w and $FF shl BShift) or (w and $FF shl GShift) or (LandPixels[y,x] and AMask);
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1377
                LandPixels[y,x]:= w or (LandPixels[y, x] and AMask)
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1378
                end
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1379
    else
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1380
        for x:= leftX div 2 to rightX div 2 do
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1381
            for y:= topY div 2 to LAND_HEIGHT-1 div 2 do
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1382
                begin
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1383
                w:= LandPixels[y div 2,x div 2];
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1384
                w:= ((w shr RShift and $FF) +  (w shr BShift and $FF) + (w shr GShift and $FF)) div 3;
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1385
                if w > 255 then w:= 255;
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1386
               w:= (w and $FF shl RShift) or (w and $FF shl BShift) or (w and $FF shl GShift) or (LandPixels[y div 2,x div 2] and AMask);
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1387
                LandPixels[y,x]:= w or (LandPixels[y div 2, x div 2] and AMask)
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1388
                end
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1389
    end;
39962b855540 Add grayscale option for 3d, helps with colour clashing
nemo
parents: 5274
diff changeset
  1390
1807
795f97007833 Split land texture into small ones:
unc0rr
parents: 1806
diff changeset
  1391
UpdateLandTexture(0, LAND_WIDTH, 0, LAND_HEIGHT);
37
2b7f2a43b999 - Properly get seed in net game
unc0rr
parents: 35
diff changeset
  1392
end;
2b7f2a43b999 - Properly get seed in net game
unc0rr
parents: 35
diff changeset
  1393
566
1c1cb593cb81 Save some memory
unc0rr
parents: 561
diff changeset
  1394
function GenPreview: TPreview;
3617
1df21e06b8ba a couple of fixes i missed previously
koda
parents: 3612
diff changeset
  1395
var x, y, xx, yy, t, bit, cbit, lh, lw: LongInt;
566
1c1cb593cb81 Save some memory
unc0rr
parents: 561
diff changeset
  1396
    Preview: TPreview;
155
401f4ea24715 Engine can generate land preview and send it via IPC
unc0rr
parents: 109
diff changeset
  1397
begin
3365
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1398
    WriteLnToConsole('Generating preview...');
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1399
    case cMapGen of
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1400
        0: GenBlank(EdgeTemplates[SelectTemplate]);
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1401
        1: GenMaze;
4494
9585435e20f7 Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents: 4458
diff changeset
  1402
        2: GenDrawnMap;
4562
b55f78fd2bf6 - Simplify map container code a bit
unc0rr
parents: 4559
diff changeset
  1403
    else
b55f78fd2bf6 - Simplify map container code a bit
unc0rr
parents: 4559
diff changeset
  1404
        OutError('Unknown mapgen', true);
3365
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1405
    end;
155
401f4ea24715 Engine can generate land preview and send it via IPC
unc0rr
parents: 109
diff changeset
  1406
3617
1df21e06b8ba a couple of fixes i missed previously
koda
parents: 3612
diff changeset
  1407
    lh:= LAND_HEIGHT div 128;
1df21e06b8ba a couple of fixes i missed previously
koda
parents: 3612
diff changeset
  1408
    lw:= LAND_WIDTH div 32;
3365
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1409
    for y:= 0 to 127 do
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1410
        for x:= 0 to 31 do
155
401f4ea24715 Engine can generate land preview and send it via IPC
unc0rr
parents: 109
diff changeset
  1411
        begin
3365
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1412
            Preview[y, x]:= 0;
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1413
            for bit:= 0 to 7 do
155
401f4ea24715 Engine can generate land preview and send it via IPC
unc0rr
parents: 109
diff changeset
  1414
            begin
3365
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1415
                t:= 0;
3617
1df21e06b8ba a couple of fixes i missed previously
koda
parents: 3612
diff changeset
  1416
                cbit:= bit * 8;
1df21e06b8ba a couple of fixes i missed previously
koda
parents: 3612
diff changeset
  1417
                for yy:= y * lh to y * lh + 7 do
1df21e06b8ba a couple of fixes i missed previously
koda
parents: 3612
diff changeset
  1418
                    for xx:= x * lw + cbit to x * lw + cbit + 7 do
3365
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1419
                        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
  1420
                if t > 8 then
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1421
                    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
  1422
            end;
566
1c1cb593cb81 Save some memory
unc0rr
parents: 561
diff changeset
  1423
        end;
3365
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1424
37ac593e9027 wow all these files only for land preview and seed generation
koda
parents: 3287
diff changeset
  1425
    GenPreview:= Preview
155
401f4ea24715 Engine can generate land preview and send it via IPC
unc0rr
parents: 109
diff changeset
  1426
end;
401f4ea24715 Engine can generate land preview and send it via IPC
unc0rr
parents: 109
diff changeset
  1427
4398
36d7e4b6ca81 Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents: 4389
diff changeset
  1428
36d7e4b6ca81 Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents: 4389
diff changeset
  1429
procedure chLandCheck(var s: shortstring);
36d7e4b6ca81 Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents: 4389
diff changeset
  1430
begin
36d7e4b6ca81 Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents: 4389
diff changeset
  1431
    AddFileLog('CheckLandDigest: ' + s + ' digest : ' + digest);
36d7e4b6ca81 Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents: 4389
diff changeset
  1432
    if digest = '' then
36d7e4b6ca81 Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents: 4389
diff changeset
  1433
        digest:= s
36d7e4b6ca81 Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents: 4389
diff changeset
  1434
    else
6025
cac1d5601d7c reviewed the build system and parts of the previous merge, performed some code cleanup
koda
parents: 6023
diff changeset
  1435
        TryDo(s = digest, 'Different maps generated, sorry', true);
4398
36d7e4b6ca81 Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents: 4389
diff changeset
  1436
end;
36d7e4b6ca81 Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents: 4389
diff changeset
  1437
36d7e4b6ca81 Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents: 4389
diff changeset
  1438
procedure chSendLandDigest(var s: shortstring);
36d7e4b6ca81 Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents: 4389
diff changeset
  1439
var adler, i: LongInt;
36d7e4b6ca81 Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents: 4389
diff changeset
  1440
begin
36d7e4b6ca81 Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents: 4389
diff changeset
  1441
    adler:= 1;
36d7e4b6ca81 Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents: 4389
diff changeset
  1442
    for i:= 0 to LAND_HEIGHT-1 do
36d7e4b6ca81 Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents: 4389
diff changeset
  1443
        Adler32Update(adler, @Land[i,0], LAND_WIDTH);
6254
e90fb60cb46d Force a desync if there is a script name mismatch. This avoids playing until the game desyncs due to script differences.
nemo
parents: 6096
diff changeset
  1444
    s:= 'M' + IntToStr(adler) + cScriptName;
4398
36d7e4b6ca81 Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents: 4389
diff changeset
  1445
36d7e4b6ca81 Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents: 4389
diff changeset
  1446
    chLandCheck(s);
36d7e4b6ca81 Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents: 4389
diff changeset
  1447
    SendIPCRaw(@s[0], Length(s) + 1)
36d7e4b6ca81 Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents: 4389
diff changeset
  1448
end;
36d7e4b6ca81 Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents: 4389
diff changeset
  1449
3038
4e48c276a468 In pascal unit is a namespace
unc0rr
parents: 3017
diff changeset
  1450
procedure initModule;
2699
249adefa9c1c replace initialization/finalization statements with custom init functions
koda
parents: 2692
diff changeset
  1451
begin
4398
36d7e4b6ca81 Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents: 4389
diff changeset
  1452
    RegisterVariable('landcheck', vtCommand, @chLandCheck, false);
36d7e4b6ca81 Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents: 4389
diff changeset
  1453
    RegisterVariable('sendlanddigest', vtCommand, @chSendLandDigest, false);
36d7e4b6ca81 Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents: 4389
diff changeset
  1454
2948
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents: 2905
diff changeset
  1455
    LandBackSurface:= nil;
3369
c7289e42f0ee add other controls for map preview, also fix a bug in digest
koda
parents: 3365
diff changeset
  1456
    digest:= '';
3612
b50215a8a43d land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents: 3608
diff changeset
  1457
b50215a8a43d land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents: 3608
diff changeset
  1458
    if (cReducedQuality and rqBlurryLand) = 0 then
b50215a8a43d land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents: 3608
diff changeset
  1459
        SetLength(LandPixels, LAND_HEIGHT, LAND_WIDTH)
b50215a8a43d land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents: 3608
diff changeset
  1460
    else
b50215a8a43d land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents: 3608
diff changeset
  1461
        SetLength(LandPixels, LAND_HEIGHT div 2, LAND_WIDTH div 2);
b50215a8a43d land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents: 3608
diff changeset
  1462
b50215a8a43d land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents: 3608
diff changeset
  1463
    SetLength(Land, LAND_HEIGHT, LAND_WIDTH);
b50215a8a43d land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents: 3608
diff changeset
  1464
    SetLength(LandDirty, (LAND_HEIGHT div 32), (LAND_WIDTH div 32));
2699
249adefa9c1c replace initialization/finalization statements with custom init functions
koda
parents: 2692
diff changeset
  1465
end;
51
b6e3ae05857f - Get rid of hwserv and runhelper
unc0rr
parents: 37
diff changeset
  1466
3038
4e48c276a468 In pascal unit is a namespace
unc0rr
parents: 3017
diff changeset
  1467
procedure freeModule;
2699
249adefa9c1c replace initialization/finalization statements with custom init functions
koda
parents: 2692
diff changeset
  1468
begin
3612
b50215a8a43d land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents: 3608
diff changeset
  1469
    Land:= nil;
b50215a8a43d land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents: 3608
diff changeset
  1470
    LandPixels:= nil;
b50215a8a43d land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents: 3608
diff changeset
  1471
    LandDirty:= nil;
2699
249adefa9c1c replace initialization/finalization statements with custom init functions
koda
parents: 2692
diff changeset
  1472
end;
249adefa9c1c replace initialization/finalization statements with custom init functions
koda
parents: 2692
diff changeset
  1473
4
bcbd7adb4e4b - set svn:eol-style to native
unc0rr
parents: 1
diff changeset
  1474
end.