hedgewars: hedgewars/uLandGraphics.pas@51062794ed01 (annotated)

393 db01cc79f278 Update copyright information unc0rr parents: 371 diff changeset	1	(*
1066 1f1b3686a2b0 Update copyright headers a bit unc0rr parents: 883 diff changeset	2	* Hedgewars, a free turn based strategy game
3236 4ab3917d7d44 Update (c) lines to 2010 as unc0rr requested - they all had varying values so I just took the first year mentioned, then tacked on -2010 nemo parents: 2981 diff changeset	3	* Copyright (c) 2005-2010 Andrey Korotaev <unC0Rr@gmail.com>
393 db01cc79f278 Update copyright information unc0rr parents: 371 diff changeset	4	*
db01cc79f278 Update copyright information unc0rr parents: 371 diff changeset	5	* This program is free software; you can redistribute it and/or modify
db01cc79f278 Update copyright information unc0rr parents: 371 diff changeset	6	* it under the terms of the GNU General Public License as published by
db01cc79f278 Update copyright information unc0rr parents: 371 diff changeset	7	* the Free Software Foundation; version 2 of the License
db01cc79f278 Update copyright information unc0rr parents: 371 diff changeset	8	*
db01cc79f278 Update copyright information unc0rr parents: 371 diff changeset	9	* This program is distributed in the hope that it will be useful,
db01cc79f278 Update copyright information unc0rr parents: 371 diff changeset	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
db01cc79f278 Update copyright information unc0rr parents: 371 diff changeset	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
db01cc79f278 Update copyright information unc0rr parents: 371 diff changeset	12	* GNU General Public License for more details.
db01cc79f278 Update copyright information unc0rr parents: 371 diff changeset	13	*
db01cc79f278 Update copyright information unc0rr parents: 371 diff changeset	14	* You should have received a copy of the GNU General Public License
db01cc79f278 Update copyright information unc0rr parents: 371 diff changeset	15	* along with this program; if not, write to the Free Software
db01cc79f278 Update copyright information unc0rr parents: 371 diff changeset	16	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
db01cc79f278 Update copyright information unc0rr parents: 371 diff changeset	17	*)
db01cc79f278 Update copyright information unc0rr parents: 371 diff changeset	18
2630 079ef82eac75 revamped file access and debug display koda parents: 2603 diff changeset	19	{$INCLUDE "options.inc"}
079ef82eac75 revamped file access and debug display koda parents: 2603 diff changeset	20
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	21	unit uLandGraphics;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	22	interface
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	23	uses uFloat, uConsts;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	24
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	25	type PRangeArray = ^TRangeArray;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	26	TRangeArray = array[0..31] of record
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	27	Left, Right: LongInt;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	28	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	29
2716 b9ca1bfca24f complete the replacement of init/free wrappers for every unit koda parents: 2695 diff changeset	30	function SweepDirty: boolean;
b9ca1bfca24f complete the replacement of init/free wrappers for every unit koda parents: 2695 diff changeset	31	function Despeckle(X, Y: LongInt): boolean;
3509 d72c2219595d Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag) nemo parents: 3236 diff changeset	32	function CheckLandValue(X, Y: LongInt; LandFlag: Word): boolean;
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	33	procedure DrawExplosion(X, Y, Radius: LongInt);
731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	34	procedure DrawHLinesExplosions(ar: PRangeArray; Radius: LongInt; y, dY: LongInt; Count: Byte);
731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	35	procedure DrawTunnel(X, Y, dX, dY: hwFloat; ticks, HalfWidth: LongInt);
731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	36	procedure FillRoundInLand(X, Y, Radius: LongInt; Value: Longword);
511 2b5b9e00419d - Further work on new collisions implementation unc0rr parents: 505 diff changeset	37	procedure ChangeRoundInLand(X, Y, Radius: LongInt; doSet: boolean);
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	38
520 e83dfb7ffead Teleportation tool unc0rr parents: 511 diff changeset	39	function TryPlaceOnLand(cpX, cpY: LongInt; Obj: TSprite; Frame: LongInt; doPlace: boolean): boolean;
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	40
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	41	implementation
1806 3c4f0886c123 More reorganization unc0rr parents: 1792 diff changeset	42	uses SDLh, uMisc, uLand, uLandTexture;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	43
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	44	procedure FillCircleLines(x, y, dx, dy: LongInt; Value: Longword);
731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	45	var i: LongInt;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	46	begin
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	47	if ((y + dy) and LAND_HEIGHT_MASK) = 0 then
2376 ece7b87f1334 Strip trailing spaces nemo parents: 2331 diff changeset	48	for i:= max(x - dx, 0) to min(x + dx, LAND_WIDTH - 1) do
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	49	if (Land[y + dy, i] and lfIndestructible) = 0 then
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	50	Land[y + dy, i]:= Value;
2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	51	if ((y - dy) and LAND_HEIGHT_MASK) = 0 then
2376 ece7b87f1334 Strip trailing spaces nemo parents: 2331 diff changeset	52	for i:= max(x - dx, 0) to min(x + dx, LAND_WIDTH - 1) do
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	53	if (Land[y - dy, i] and lfIndestructible) = 0 then
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	54	Land[y - dy, i]:= Value;
2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	55	if ((y + dx) and LAND_HEIGHT_MASK) = 0 then
2376 ece7b87f1334 Strip trailing spaces nemo parents: 2331 diff changeset	56	for i:= max(x - dy, 0) to min(x + dy, LAND_WIDTH - 1) do
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	57	if (Land[y + dx, i] and lfIndestructible) = 0 then
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	58	Land[y + dx, i]:= Value;
2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	59	if ((y - dx) and LAND_HEIGHT_MASK) = 0 then
2376 ece7b87f1334 Strip trailing spaces nemo parents: 2331 diff changeset	60	for i:= max(x - dy, 0) to min(x + dy, LAND_WIDTH - 1) do
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	61	if (Land[y - dx, i] and lfIndestructible) = 0 then
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	62	Land[y - dx, i]:= Value;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	63	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	64
511 2b5b9e00419d - Further work on new collisions implementation unc0rr parents: 505 diff changeset	65	procedure ChangeCircleLines(x, y, dx, dy: LongInt; doSet: boolean);
504 13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	66	var i: LongInt;
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	67	begin
511 2b5b9e00419d - Further work on new collisions implementation unc0rr parents: 505 diff changeset	68	if not doSet then
2b5b9e00419d - Further work on new collisions implementation unc0rr parents: 505 diff changeset	69	begin
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	70	if ((y + dy) and LAND_HEIGHT_MASK) = 0 then
1760 55a1edd97911 Fix nemo's large land patch unc0rr parents: 1753 diff changeset	71	for i:= max(x - dx, 0) to min(x + dx, LAND_WIDTH - 1) do
1861 98de5dc5fda7 nemo: unc0rr parents: 1849 diff changeset	72	if (Land[y + dy, i] > 0) and (Land[y + dy, i] < 256) then dec(Land[y + dy, i]); // check > 0 because explosion can erase collision data
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	73	if ((y - dy) and LAND_HEIGHT_MASK) = 0 then
1760 55a1edd97911 Fix nemo's large land patch unc0rr parents: 1753 diff changeset	74	for i:= max(x - dx, 0) to min(x + dx, LAND_WIDTH - 1) do
1861 98de5dc5fda7 nemo: unc0rr parents: 1849 diff changeset	75	if (Land[y - dy, i] > 0) and (Land[y - dy, i] < 256) then dec(Land[y - dy, i]);
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	76	if ((y + dx) and LAND_HEIGHT_MASK) = 0 then
1760 55a1edd97911 Fix nemo's large land patch unc0rr parents: 1753 diff changeset	77	for i:= max(x - dy, 0) to min(x + dy, LAND_WIDTH - 1) do
1861 98de5dc5fda7 nemo: unc0rr parents: 1849 diff changeset	78	if (Land[y + dx, i] > 0) and (Land[y + dx, i] < 256) then dec(Land[y + dx, i]);
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	79	if ((y - dx) and LAND_HEIGHT_MASK) = 0 then
1760 55a1edd97911 Fix nemo's large land patch unc0rr parents: 1753 diff changeset	80	for i:= max(x - dy, 0) to min(x + dy, LAND_WIDTH - 1) do
1861 98de5dc5fda7 nemo: unc0rr parents: 1849 diff changeset	81	if (Land[y - dx, i] > 0) and (Land[y - dx, i] < 256) then dec(Land[y - dx, i]);
511 2b5b9e00419d - Further work on new collisions implementation unc0rr parents: 505 diff changeset	82	end else
2b5b9e00419d - Further work on new collisions implementation unc0rr parents: 505 diff changeset	83	begin
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	84	if ((y + dy) and LAND_HEIGHT_MASK) = 0 then
2376 ece7b87f1334 Strip trailing spaces nemo parents: 2331 diff changeset	85	for i:= max(x - dx, 0) to min(x + dx, LAND_WIDTH - 1) do
1861 98de5dc5fda7 nemo: unc0rr parents: 1849 diff changeset	86	if (Land[y + dy, i] < 256) then
98de5dc5fda7 nemo: unc0rr parents: 1849 diff changeset	87	inc(Land[y + dy, i]);
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	88	if ((y - dy) and LAND_HEIGHT_MASK) = 0 then
2376 ece7b87f1334 Strip trailing spaces nemo parents: 2331 diff changeset	89	for i:= max(x - dx, 0) to min(x + dx, LAND_WIDTH - 1) do
1861 98de5dc5fda7 nemo: unc0rr parents: 1849 diff changeset	90	if (Land[y - dy, i] < 256) then
98de5dc5fda7 nemo: unc0rr parents: 1849 diff changeset	91	inc(Land[y - dy, i]);
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	92	if ((y + dx) and LAND_HEIGHT_MASK) = 0 then
1861 98de5dc5fda7 nemo: unc0rr parents: 1849 diff changeset	93	for i:= max(x - dy, 0) to min(x + dy, LAND_WIDTH - 1) do
98de5dc5fda7 nemo: unc0rr parents: 1849 diff changeset	94	if (Land[y + dx, i] < 256) then
98de5dc5fda7 nemo: unc0rr parents: 1849 diff changeset	95	inc(Land[y + dx, i]);
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	96	if ((y - dx) and LAND_HEIGHT_MASK) = 0 then
1861 98de5dc5fda7 nemo: unc0rr parents: 1849 diff changeset	97	for i:= max(x - dy, 0) to min(x + dy, LAND_WIDTH - 1) do
98de5dc5fda7 nemo: unc0rr parents: 1849 diff changeset	98	if (Land[y - dx, i] < 256) then
98de5dc5fda7 nemo: unc0rr parents: 1849 diff changeset	99	inc(Land[y - dx, i]);
511 2b5b9e00419d - Further work on new collisions implementation unc0rr parents: 505 diff changeset	100	end
504 13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	101	end;
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	102
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	103	procedure FillRoundInLand(X, Y, Radius: LongInt; Value: Longword);
731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	104	var dx, dy, d: LongInt;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	105	begin
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	106	dx:= 0;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	107	dy:= Radius;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	108	d:= 3 - 2 * Radius;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	109	while (dx < dy) do
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	110	begin
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	111	FillCircleLines(x, y, dx, dy, Value);
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	112	if (d < 0)
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	113	then d:= d + 4 * dx + 6
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	114	else begin
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	115	d:= d + 4 * (dx - dy) + 10;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	116	dec(dy)
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	117	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	118	inc(dx)
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	119	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	120	if (dx = dy) then FillCircleLines(x, y, dx, dy, Value);
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	121	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	122
511 2b5b9e00419d - Further work on new collisions implementation unc0rr parents: 505 diff changeset	123	procedure ChangeRoundInLand(X, Y, Radius: LongInt; doSet: boolean);
504 13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	124	var dx, dy, d: LongInt;
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	125	begin
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	126	dx:= 0;
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	127	dy:= Radius;
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	128	d:= 3 - 2 * Radius;
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	129	while (dx < dy) do
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	130	begin
511 2b5b9e00419d - Further work on new collisions implementation unc0rr parents: 505 diff changeset	131	ChangeCircleLines(x, y, dx, dy, doSet);
504 13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	132	if (d < 0)
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	133	then d:= d + 4 * dx + 6
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	134	else begin
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	135	d:= d + 4 * (dx - dy) + 10;
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	136	dec(dy)
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	137	end;
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	138	inc(dx)
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	139	end;
511 2b5b9e00419d - Further work on new collisions implementation unc0rr parents: 505 diff changeset	140	if (dx = dy) then ChangeCircleLines(x, y, dx, dy, doSet)
504 13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	141	end;
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	142
2603 abed6070a669 revert previous commit to remove a wip patch koda parents: 2602 diff changeset	143	procedure FillLandCircleLines0(x, y, dx, dy: LongInt);
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	144	var i, t: LongInt;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	145	begin
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	146	t:= y + dy;
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	147	if (t and LAND_HEIGHT_MASK) = 0 then
2376 ece7b87f1334 Strip trailing spaces nemo parents: 2331 diff changeset	148	for i:= max(x - dx, 0) to min(x + dx, LAND_WIDTH - 1) do
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	149	if (not isMap and ((Land[t, i] and lfIndestructible) = 0)) or ((Land[t, i] and lfBasic) <> 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: 3554 diff changeset	150	if (cReducedQuality and rqBlurryLand) = 0 then
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	151	LandPixels[t, i]:= 0
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	152	else
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	153	LandPixels[t div 2, i div 2]:= 0;
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	154
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	155	t:= y - dy;
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	156	if (t and LAND_HEIGHT_MASK) = 0 then
2376 ece7b87f1334 Strip trailing spaces nemo parents: 2331 diff changeset	157	for i:= max(x - dx, 0) to min(x + dx, LAND_WIDTH - 1) do
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	158	if (not isMap and ((Land[t, i] and lfIndestructible) = 0)) or ((Land[t, i] and lfBasic) <> 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: 3554 diff changeset	159	if (cReducedQuality and rqBlurryLand) = 0 then
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	160	LandPixels[t, i]:= 0
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	161	else
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	162	LandPixels[t div 2, i div 2]:= 0;
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	163
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	164	t:= y + dx;
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	165	if (t and LAND_HEIGHT_MASK) = 0 then
2376 ece7b87f1334 Strip trailing spaces nemo parents: 2331 diff changeset	166	for i:= max(x - dy, 0) to min(x + dy, LAND_WIDTH - 1) do
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	167	if (not isMap and ((Land[t, i] and lfIndestructible) = 0)) or ((Land[t, i] and lfBasic) <> 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: 3554 diff changeset	168	if (cReducedQuality and rqBlurryLand) = 0 then
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	169	LandPixels[t, i]:= 0
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	170	else
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	171	LandPixels[t div 2, i div 2]:= 0;
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	172
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	173	t:= y - dx;
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	174	if (t and LAND_HEIGHT_MASK) = 0 then
2376 ece7b87f1334 Strip trailing spaces nemo parents: 2331 diff changeset	175	for i:= max(x - dy, 0) to min(x + dy, LAND_WIDTH - 1) do
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	176	if (not isMap and ((Land[t, i] and lfIndestructible) = 0)) or ((Land[t, i] and lfBasic) <> 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: 3554 diff changeset	177	if (cReducedQuality and rqBlurryLand) = 0 then
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	178	LandPixels[t, i]:= 0
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	179	else
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	180	LandPixels[t div 2, i div 2]:= 0;
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	181
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	182	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	183
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	184	procedure FillLandCircleLinesBG(x, y, dx, dy: LongInt);
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	185	var i, t: LongInt;
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	186	begin
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	187	t:= y + dy;
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	188	if (t and LAND_HEIGHT_MASK) = 0 then
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	189	for i:= max(x - dx, 0) to min(x + dx, LAND_WIDTH - 1) do
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	190	if ((Land[t, i] and lfBasic) <> 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: 3554 diff changeset	191	if (cReducedQuality and rqBlurryLand) = 0 then
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	192	LandPixels[t, i]:= LandBackPixel(i, t)
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	193	else
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	194	LandPixels[t div 2, i div 2]:= LandBackPixel(i, t)
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	195	else
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	196	if ((Land[t, i] and lfObject) <> 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: 3554 diff changeset	197	if (cReducedQuality and rqBlurryLand) = 0 then
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	198	LandPixels[t, i]:= 0
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	199	else
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	200	LandPixels[t div 2, i div 2]:= 0;
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	201
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	202	t:= y - dy;
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	203	if (t and LAND_HEIGHT_MASK) = 0 then
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	204	for i:= max(x - dx, 0) to min(x + dx, LAND_WIDTH - 1) do
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	205	if ((Land[t, i] and lfBasic) <> 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: 3554 diff changeset	206	if (cReducedQuality and rqBlurryLand) = 0 then
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	207	LandPixels[t, i]:= LandBackPixel(i, t)
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	208	else
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	209	LandPixels[t div 2, i div 2]:= LandBackPixel(i, t)
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	210	else
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	211	if ((Land[t, i] and lfObject) <> 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: 3554 diff changeset	212	if (cReducedQuality and rqBlurryLand) = 0 then
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	213	LandPixels[t, i]:= 0
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	214	else
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	215	LandPixels[t div 2, i div 2]:= 0;
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	216
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	217	t:= y + dx;
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	218	if (t and LAND_HEIGHT_MASK) = 0 then
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	219	for i:= max(x - dy, 0) to min(x + dy, LAND_WIDTH - 1) do
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	220	if ((Land[t, i] and lfBasic) <> 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: 3554 diff changeset	221	if (cReducedQuality and rqBlurryLand) = 0 then
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	222	LandPixels[t, i]:= LandBackPixel(i, t)
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	223	else
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	224	LandPixels[t div 2, i div 2]:= LandBackPixel(i, t)
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	225	else
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	226	if ((Land[t, i] and lfObject) <> 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: 3554 diff changeset	227	if (cReducedQuality and rqBlurryLand) = 0 then
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	228	LandPixels[t, i]:= 0
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	229	else
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	230	LandPixels[t div 2, i div 2]:= 0;
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	231
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	232	t:= y - dx;
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	233	if (t and LAND_HEIGHT_MASK) = 0 then
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	234	for i:= max(x - dy, 0) to min(x + dy, LAND_WIDTH - 1) do
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	235	if ((Land[t, i] and lfBasic) <> 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: 3554 diff changeset	236	if (cReducedQuality and rqBlurryLand) = 0 then
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	237	LandPixels[t, i]:= LandBackPixel(i, t)
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	238	else
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	239	LandPixels[t div 2, i div 2]:= LandBackPixel(i, t)
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	240
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	241	else
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	242	if ((Land[t, i] and lfObject) <> 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: 3554 diff changeset	243	if (cReducedQuality and rqBlurryLand) = 0 then
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	244	LandPixels[t, i]:= 0
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	245	else
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	246	LandPixels[t div 2, i div 2]:= 0;
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	247
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	248	end;
0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	249
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	250	procedure FillLandCircleLinesEBC(x, y, dx, dy: LongInt);
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	251	var i, t: LongInt;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	252	begin
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	253	t:= y + dy;
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	254	if (t and LAND_HEIGHT_MASK) = 0 then
1760 55a1edd97911 Fix nemo's large land patch unc0rr parents: 1753 diff changeset	255	for i:= max(x - dx, 0) to min(x + dx, LAND_WIDTH - 1) do
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	256	if ((Land[t, i] and lfBasic) <> 0) or ((Land[t, i] and lfObject) <> 0) then
1738 00e8dadce69a Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays unc0rr parents: 1066 diff changeset	257	begin
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	258	if (cReducedQuality and rqBlurryLand) = 0 then
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	259	LandPixels[t, i]:= cExplosionBorderColor
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	260	else
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	261	LandPixels[t div 2, i div 2]:= cExplosionBorderColor;
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	262
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	263	Land[t, i]:= Land[t, i] or lfDamaged;
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	264	//Despeckle(i, t);
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	265	LandDirty[t div 32, i div 32]:= 1;
1738 00e8dadce69a Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays unc0rr parents: 1066 diff changeset	266	end;
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	267
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	268	t:= y - dy;
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	269	if (t and LAND_HEIGHT_MASK) = 0 then
1760 55a1edd97911 Fix nemo's large land patch unc0rr parents: 1753 diff changeset	270	for i:= max(x - dx, 0) to min(x + dx, LAND_WIDTH - 1) do
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	271	if ((Land[t, i] and lfBasic) <> 0) or ((Land[t, i] and lfObject) <> 0) then
1738 00e8dadce69a Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays unc0rr parents: 1066 diff changeset	272	begin
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	273	if (cReducedQuality and rqBlurryLand) = 0 then
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	274	LandPixels[t, i]:= cExplosionBorderColor
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	275	else
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	276	LandPixels[t div 2, i div 2]:= cExplosionBorderColor;
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	277	Land[t, i]:= Land[t, i] or lfDamaged;
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	278	//Despeckle(i, t);
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	279	LandDirty[t div 32, i div 32]:= 1;
1738 00e8dadce69a Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays unc0rr parents: 1066 diff changeset	280	end;
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	281
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	282	t:= y + dx;
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	283	if (t and LAND_HEIGHT_MASK) = 0 then
1760 55a1edd97911 Fix nemo's large land patch unc0rr parents: 1753 diff changeset	284	for i:= max(x - dy, 0) to min(x + dy, LAND_WIDTH - 1) do
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	285	if ((Land[t, i] and lfBasic) <> 0) or ((Land[t, i] and lfObject) <> 0) then
1738 00e8dadce69a Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays unc0rr parents: 1066 diff changeset	286	begin
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	287	if (cReducedQuality and rqBlurryLand) = 0 then
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	288	LandPixels[t, i]:= cExplosionBorderColor
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	289	else
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	290	LandPixels[t div 2, i div 2]:= cExplosionBorderColor;
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	291
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	292	Land[t, i]:= Land[t, i] or lfDamaged;
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	293	//Despeckle(i, t);
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	294	LandDirty[t div 32, i div 32]:= 1;
1738 00e8dadce69a Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays unc0rr parents: 1066 diff changeset	295	end;
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	296
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	297	t:= y - dx;
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	298	if (t and LAND_HEIGHT_MASK) = 0 then
1760 55a1edd97911 Fix nemo's large land patch unc0rr parents: 1753 diff changeset	299	for i:= max(x - dy, 0) to min(x + dy, LAND_WIDTH - 1) do
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	300	if ((Land[t, i] and lfBasic) <> 0) or ((Land[t, i] and lfObject) <> 0) then
1738 00e8dadce69a Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays unc0rr parents: 1066 diff changeset	301	begin
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	302	if (cReducedQuality and rqBlurryLand) = 0 then
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	303	LandPixels[t, i]:= cExplosionBorderColor
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	304	else
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	305	LandPixels[t div 2, i div 2]:= cExplosionBorderColor;
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	306
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	307	Land[t, i]:= Land[t, i] or lfDamaged;
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	308	//Despeckle(i, y - dy);
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	309	LandDirty[t div 32, i div 32]:= 1;
1738 00e8dadce69a Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays unc0rr parents: 1066 diff changeset	310	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	311	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	312
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	313	procedure DrawExplosion(X, Y, Radius: LongInt);
2603 abed6070a669 revert previous commit to remove a wip patch koda parents: 2602 diff changeset	314	var dx, dy, ty, tx, d: LongInt;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	315	begin
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	316
0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	317	// draw background land texture
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	318	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	319	dx:= 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	320	dy:= Radius;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	321	d:= 3 - 2 * Radius;
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	322
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	323	while (dx < dy) do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	324	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	325	FillLandCircleLinesBG(x, y, dx, dy);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	326	if (d < 0)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	327	then d:= d + 4 * dx + 6
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	328	else begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	329	d:= d + 4 * (dx - dy) + 10;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	330	dec(dy)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	331	end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	332	inc(dx)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	333	end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	334	if (dx = dy) then FillLandCircleLinesBG(x, y, dx, dy);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	335	end;
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	336
0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	337	// draw a hole in land
2733 52a5a160566f Engine: smxx parents: 2716 diff changeset	338	if Radius > 20 then
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	339	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	340	dx:= 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	341	dy:= Radius - 15;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	342	d:= 3 - 2 * dy;
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	343
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	344	while (dx < dy) do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	345	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	346	FillLandCircleLines0(x, y, dx, dy);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	347	if (d < 0)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	348	then d:= d + 4 * dx + 6
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	349	else begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	350	d:= d + 4 * (dx - dy) + 10;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	351	dec(dy)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	352	end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	353	inc(dx)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	354	end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	355	if (dx = dy) then FillLandCircleLines0(x, y, dx, dy);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	356	end;
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	357
1849 2a989e5abda6 4 utilities by nemo unc0rr parents: 1809 diff changeset	358	// FillRoundInLand after erasing land pixels to allow Land 0 check for mask.png to function
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	359	FillRoundInLand(X, Y, Radius, 0);
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	360
0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	361	// draw explosion border
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	362	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	363	inc(Radius, 4);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	364	dx:= 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	365	dy:= Radius;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	366	d:= 3 - 2 * Radius;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	367	while (dx < dy) do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	368	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	369	FillLandCircleLinesEBC(x, y, dx, dy);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	370	if (d < 0)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	371	then d:= d + 4 * dx + 6
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	372	else begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	373	d:= d + 4 * (dx - dy) + 10;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	374	dec(dy)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	375	end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	376	inc(dx)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	377	end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	378	if (dx = dy) then FillLandCircleLinesEBC(x, y, dx, dy);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	379	end;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 345 diff changeset	380
1807 795f97007833 Split land texture into small ones: unc0rr parents: 1806 diff changeset	381	tx:= max(X - Radius - 1, 0);
795f97007833 Split land texture into small ones: unc0rr parents: 1806 diff changeset	382	dx:= min(X + Radius + 1, LAND_WIDTH) - tx;
795f97007833 Split land texture into small ones: unc0rr parents: 1806 diff changeset	383	ty:= max(Y - Radius - 1, 0);
795f97007833 Split land texture into small ones: unc0rr parents: 1806 diff changeset	384	dy:= min(Y + Radius + 1, LAND_HEIGHT) - ty;
795f97007833 Split land texture into small ones: unc0rr parents: 1806 diff changeset	385	UpdateLandTexture(tx, dx, ty, dy)
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	386	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	387
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	388	procedure DrawHLinesExplosions(ar: PRangeArray; Radius: LongInt; y, dY: LongInt; Count: Byte);
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	389	var tx, ty, i: LongInt;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	390	begin
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	391	for i:= 0 to Pred(Count) do
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	392	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	393	for ty:= max(y - Radius, 0) to min(y + Radius, LAND_HEIGHT) do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	394	for tx:= max(0, ar^[i].Left - Radius) to min(LAND_WIDTH, ar^[i].Right + Radius) do
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	395	if (Land[ty, tx] and lfBasic) <> 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: 3554 diff changeset	396	if (cReducedQuality and rqBlurryLand) = 0 then
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	397	LandPixels[ty, tx]:= LandBackPixel(tx, ty)
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	398	else
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	399	LandPixels[ty div 2, tx div 2]:= LandBackPixel(tx, ty)
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	400	else
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	401	if (Land[ty, tx] and lfObject) <> 0 then
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	402	if (cReducedQuality and rqBlurryLand) = 0 then
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	403	LandPixels[ty, tx]:= 0
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	404	else
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	405	LandPixels[ty div 2, tx div 2]:= 0;
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	406	inc(y, dY)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	407	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	408
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	409	inc(Radius, 4);
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 345 diff changeset	410	dec(y, Count * dY);
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	411
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	412	for i:= 0 to Pred(Count) do
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	413	begin
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	414	for ty:= max(y - Radius, 0) to min(y + Radius, LAND_HEIGHT) do
2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	415	for tx:= max(0, ar^[i].Left - Radius) to min(LAND_WIDTH, ar^[i].Right + Radius) do
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	416	if ((Land[ty, tx] and lfBasic) <> 0) or ((Land[ty, tx] and lfObject) <> 0) then
1738 00e8dadce69a Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays unc0rr parents: 1066 diff changeset	417	begin
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	418	if (cReducedQuality and rqBlurryLand) = 0 then
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	419	LandPixels[ty, tx]:= cExplosionBorderColor
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	420	else
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	421	LandPixels[ty div 2, tx div 2]:= cExplosionBorderColor;
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	422
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	423	Land[ty, tx]:= Land[ty, tx] or lfDamaged;
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	424	LandDirty[ty div 32, tx div 32]:= 1;
1738 00e8dadce69a Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays unc0rr parents: 1066 diff changeset	425	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	426	inc(y, dY)
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	427	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	428
818 635e58295079 Fix drill bug unc0rr parents: 772 diff changeset	429
1807 795f97007833 Split land texture into small ones: unc0rr parents: 1806 diff changeset	430	UpdateLandTexture(0, LAND_WIDTH, 0, LAND_HEIGHT)
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	431	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	432
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	433	//
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	434	// - (dX, dY) - direction, vector of length = 0.5
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	435	//
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	436	procedure DrawTunnel(X, Y, dX, dY: hwFloat; ticks, HalfWidth: LongInt);
358 236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	437	var nx, ny, dX8, dY8: hwFloat;
1809 77923087a1ce Some optimization of land texture updating unc0rr parents: 1807 diff changeset	438	i, t, tx, ty, stX, stY, ddy, ddx: Longint;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	439	begin // (-dY, dX) is (dX, dY) rotated by PI/2
772 e8d530ca77be Don't update all land texture when drawing tunnel (saves video throughput) unc0rr parents: 769 diff changeset	440	stY:= hwRound(Y);
1809 77923087a1ce Some optimization of land texture updating unc0rr parents: 1807 diff changeset	441	stX:= hwRound(X);
772 e8d530ca77be Don't update all land texture when drawing tunnel (saves video throughput) unc0rr parents: 769 diff changeset	442
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	443	nx:= X + dY * (HalfWidth + 8);
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	444	ny:= Y - dX * (HalfWidth + 8);
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	445
358 236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	446	dX8:= dX * 8;
236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	447	dY8:= dY * 8;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	448	for i:= 0 to 7 do
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	449	begin
358 236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	450	X:= nx - dX8;
236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	451	Y:= ny - dY8;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	452	for t:= -8 to ticks + 8 do
2666 2b8c8f16421e update SDLMain.m/.h to latest version koda parents: 2648 diff changeset	453	begin
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	454	X:= X + dX;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	455	Y:= Y + dY;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	456	tx:= hwRound(X);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	457	ty:= hwRound(Y);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	458	if ((ty and LAND_HEIGHT_MASK) = 0) and
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	459	((tx and LAND_WIDTH_MASK) = 0) and
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	460	(((Land[ty, tx] and lfBasic) <> 0) or
56cbc035b74b rename flags nemo parents: 3518 diff changeset	461	((Land[ty, tx] and lfObject) <> 0)) then
3509 d72c2219595d Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag) nemo parents: 3236 diff changeset	462	begin
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	463	Land[ty, tx]:= Land[ty, tx] or lfDamaged;
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	464	if (cReducedQuality and rqBlurryLand) = 0 then
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	465	LandPixels[ty, tx]:= cExplosionBorderColor
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	466	else
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	467	LandPixels[ty div 2, tx div 2]:= cExplosionBorderColor
3509 d72c2219595d Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag) nemo parents: 3236 diff changeset	468	end
2666 2b8c8f16421e update SDLMain.m/.h to latest version koda parents: 2648 diff changeset	469	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	470	nx:= nx - dY;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	471	ny:= ny + dX;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	472	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	473
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	474	for i:= -HalfWidth to HalfWidth do
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	475	begin
358 236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	476	X:= nx - dX8;
236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	477	Y:= ny - dY8;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	478	for t:= 0 to 7 do
2666 2b8c8f16421e update SDLMain.m/.h to latest version koda parents: 2648 diff changeset	479	begin
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	480	X:= X + dX;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	481	Y:= Y + dY;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	482	tx:= hwRound(X);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	483	ty:= hwRound(Y);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	484	if ((ty and LAND_HEIGHT_MASK) = 0) and
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	485	((tx and LAND_WIDTH_MASK) = 0) and
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	486	(((Land[ty, tx] and lfBasic) <> 0) or
56cbc035b74b rename flags nemo parents: 3518 diff changeset	487	((Land[ty, tx] and lfObject) <> 0)) then
3509 d72c2219595d Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag) nemo parents: 3236 diff changeset	488	begin
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	489	Land[ty, tx]:= Land[ty, tx] or lfDamaged;
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	490	if (cReducedQuality and rqBlurryLand) = 0 then
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	491	LandPixels[ty, tx]:= cExplosionBorderColor
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	492	else
3509 d72c2219595d Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag) nemo parents: 3236 diff changeset	493	LandPixels[ty div 2, tx div 2]:= cExplosionBorderColor
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	494
3509 d72c2219595d Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag) nemo parents: 3236 diff changeset	495	end
2666 2b8c8f16421e update SDLMain.m/.h to latest version koda parents: 2648 diff changeset	496	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	497	X:= nx;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	498	Y:= ny;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	499	for t:= 0 to ticks do
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	500	begin
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	501	X:= X + dX;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	502	Y:= Y + dY;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 345 diff changeset	503	tx:= hwRound(X);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 345 diff changeset	504	ty:= hwRound(Y);
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	505	if ((ty and LAND_HEIGHT_MASK) = 0) and ((tx and LAND_WIDTH_MASK) = 0) and ((Land[ty, tx] and lfIndestructible) = 0) then
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	506	begin
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	507	if (Land[ty, tx] and lfBasic) <> 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: 3554 diff changeset	508	if (cReducedQuality and rqBlurryLand) = 0 then
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	509	LandPixels[ty, tx]:= LandBackPixel(tx, ty)
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	510	else
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	511	LandPixels[ty div 2, tx div 2]:= LandBackPixel(tx, ty)
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	512	else
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	513	if (Land[ty, tx] and lfObject) <> 0 then
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	514	if (cReducedQuality and rqBlurryLand) = 0 then
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	515	LandPixels[ty, tx]:= 0
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	516	else
3509 d72c2219595d Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag) nemo parents: 3236 diff changeset	517	LandPixels[ty div 2, tx div 2]:= 0;
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	518
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	519	Land[ty, tx]:= 0;
0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	520	end
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	521	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	522	for t:= 0 to 7 do
2666 2b8c8f16421e update SDLMain.m/.h to latest version koda parents: 2648 diff changeset	523	begin
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	524	X:= X + dX;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	525	Y:= Y + dY;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	526	tx:= hwRound(X);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	527	ty:= hwRound(Y);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	528	if ((ty and LAND_HEIGHT_MASK) = 0) and
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	529	((tx and LAND_WIDTH_MASK) = 0) and
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	530	(((Land[ty, tx] and lfBasic) <> 0) or
56cbc035b74b rename flags nemo parents: 3518 diff changeset	531	((Land[ty, tx] and lfObject) <> 0)) then
3509 d72c2219595d Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag) nemo parents: 3236 diff changeset	532	begin
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	533	Land[ty, tx]:= Land[ty, tx] or lfDamaged;
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	534	if (cReducedQuality and rqBlurryLand) = 0 then
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	535	LandPixels[ty, tx]:= cExplosionBorderColor
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	536	else
3509 d72c2219595d Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag) nemo parents: 3236 diff changeset	537	LandPixels[ty div 2, tx div 2]:= cExplosionBorderColor
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	538
3509 d72c2219595d Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag) nemo parents: 3236 diff changeset	539	end
2666 2b8c8f16421e update SDLMain.m/.h to latest version koda parents: 2648 diff changeset	540	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	541	nx:= nx - dY;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	542	ny:= ny + dX;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	543	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	544
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	545	for i:= 0 to 7 do
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	546	begin
358 236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	547	X:= nx - dX8;
236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	548	Y:= ny - dY8;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	549	for t:= -8 to ticks + 8 do
2666 2b8c8f16421e update SDLMain.m/.h to latest version koda parents: 2648 diff changeset	550	begin
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	551	X:= X + dX;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	552	Y:= Y + dY;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	553	tx:= hwRound(X);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	554	ty:= hwRound(Y);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	555	if ((ty and LAND_HEIGHT_MASK) = 0) and
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	556	((tx and LAND_WIDTH_MASK) = 0) and
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	557	(((Land[ty, tx] and lfBasic) <> 0) or
56cbc035b74b rename flags nemo parents: 3518 diff changeset	558	((Land[ty, tx] and lfObject) <> 0)) then
3509 d72c2219595d Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag) nemo parents: 3236 diff changeset	559	begin
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	560	Land[ty, tx]:= Land[ty, tx] or lfDamaged;
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	561	if (cReducedQuality and rqBlurryLand) = 0 then
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	562	LandPixels[ty, tx]:= cExplosionBorderColor
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	563	else
3509 d72c2219595d Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag) nemo parents: 3236 diff changeset	564	LandPixels[ty div 2, tx div 2]:= cExplosionBorderColor
d72c2219595d Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag) nemo parents: 3236 diff changeset	565	end
2666 2b8c8f16421e update SDLMain.m/.h to latest version koda parents: 2648 diff changeset	566	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	567	nx:= nx - dY;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	568	ny:= ny + dX;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	569	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	570
1809 77923087a1ce Some optimization of land texture updating unc0rr parents: 1807 diff changeset	571	tx:= max(stX - HalfWidth * 2 - 4 - abs(hwRound(dX * ticks)), 0);
1807 795f97007833 Split land texture into small ones: unc0rr parents: 1806 diff changeset	572	ty:= max(stY - HalfWidth * 2 - 4 - abs(hwRound(dY * ticks)), 0);
1809 77923087a1ce Some optimization of land texture updating unc0rr parents: 1807 diff changeset	573	ddx:= min(stX + HalfWidth * 2 + 4 + abs(hwRound(dX * ticks)), LAND_WIDTH) - tx;
77923087a1ce Some optimization of land texture updating unc0rr parents: 1807 diff changeset	574	ddy:= min(stY + HalfWidth * 2 + 4 + abs(hwRound(dY * ticks)), LAND_HEIGHT) - ty;
77923087a1ce Some optimization of land texture updating unc0rr parents: 1807 diff changeset	575
77923087a1ce Some optimization of land texture updating unc0rr parents: 1807 diff changeset	576	UpdateLandTexture(tx, ddx, ty, ddy)
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	577	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	578
520 e83dfb7ffead Teleportation tool unc0rr parents: 511 diff changeset	579	function TryPlaceOnLand(cpX, cpY: LongInt; Obj: TSprite; Frame: LongInt; doPlace: boolean): boolean;
2235 79c9542c1058 multi-column support nemo parents: 2167 diff changeset	580	var X, Y, bpp, h, w, row, col, numFramesFirstCol: LongInt;
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	581	p: PByteArray;
769 788efc1d649f - Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization unc0rr parents: 768 diff changeset	582	Image: PSDL_Surface;
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	583	begin
2235 79c9542c1058 multi-column support nemo parents: 2167 diff changeset	584	numFramesFirstCol:= SpritesData[Obj].imageHeight div SpritesData[Obj].Height;
79c9542c1058 multi-column support nemo parents: 2167 diff changeset	585
769 788efc1d649f - Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization unc0rr parents: 768 diff changeset	586	TryDo(SpritesData[Obj].Surface <> nil, 'Assert SpritesData[Obj].Surface failed', true);
788efc1d649f - Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization unc0rr parents: 768 diff changeset	587	Image:= SpritesData[Obj].Surface;
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	588	w:= SpritesData[Obj].Width;
769 788efc1d649f - Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization unc0rr parents: 768 diff changeset	589	h:= SpritesData[Obj].Height;
2235 79c9542c1058 multi-column support nemo parents: 2167 diff changeset	590	row:= Frame mod numFramesFirstCol;
79c9542c1058 multi-column support nemo parents: 2167 diff changeset	591	col:= Frame div numFramesFirstCol;
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	592
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	593	if SDL_MustLock(Image) then
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	594	SDLTry(SDL_LockSurface(Image) >= 0, true);
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	595
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	596	bpp:= Image^.format^.BytesPerPixel;
769 788efc1d649f - Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization unc0rr parents: 768 diff changeset	597	TryDo(bpp = 4, 'It should be 32 bpp sprite', true);
788efc1d649f - Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization unc0rr parents: 768 diff changeset	598	// Check that sprite fits free space
2236 af8fc3311748 the -1 was a bad idea nemo parents: 2235 diff changeset	599	p:= @(PByteArray(Image^.pixels)^[ Image^.pitch * row * h + col * w * 4 ]);
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	600	case bpp of
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	601	4: for y:= 0 to Pred(h) do
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	602	begin
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	603	for x:= 0 to Pred(w) do
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	604	if PLongword(@(p^[x * 4]))^ <> 0 then
1792 c30c6944bd49 engine part of nemo's patch unc0rr parents: 1761 diff changeset	605	if ((cpY + y) < Longint(topY)) or
c30c6944bd49 engine part of nemo's patch unc0rr parents: 1761 diff changeset	606	((cpY + y) > LAND_HEIGHT) or
c30c6944bd49 engine part of nemo's patch unc0rr parents: 1761 diff changeset	607	((cpX + x) < Longint(leftX)) or
c30c6944bd49 engine part of nemo's patch unc0rr parents: 1761 diff changeset	608	((cpX + x) > Longint(rightX)) or
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	609	(Land[cpY + y, cpX + x] <> 0) then
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	610	begin
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	611	if SDL_MustLock(Image) then
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	612	SDL_UnlockSurface(Image);
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	613	exit(false)
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	614	end;
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	615	p:= @(p^[Image^.pitch]);
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	616	end;
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	617	end;
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	618
520 e83dfb7ffead Teleportation tool unc0rr parents: 511 diff changeset	619	TryPlaceOnLand:= true;
769 788efc1d649f - Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization unc0rr parents: 768 diff changeset	620	if not doPlace then
788efc1d649f - Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization unc0rr parents: 768 diff changeset	621	begin
788efc1d649f - Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization unc0rr parents: 768 diff changeset	622	if SDL_MustLock(Image) then
788efc1d649f - Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization unc0rr parents: 768 diff changeset	623	SDL_UnlockSurface(Image);
788efc1d649f - Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization unc0rr parents: 768 diff changeset	624	exit
788efc1d649f - Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization unc0rr parents: 768 diff changeset	625	end;
520 e83dfb7ffead Teleportation tool unc0rr parents: 511 diff changeset	626
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	627	// Checked, now place
2236 af8fc3311748 the -1 was a bad idea nemo parents: 2235 diff changeset	628	p:= @(PByteArray(Image^.pixels)^[ Image^.pitch * row * h + col * w * 4 ]);
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	629	case bpp of
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	630	4: for y:= 0 to Pred(h) do
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	631	begin
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	632	for x:= 0 to Pred(w) do
769 788efc1d649f - Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization unc0rr parents: 768 diff changeset	633	if PLongword(@(p^[x * 4]))^ <> 0 then
788efc1d649f - Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization unc0rr parents: 768 diff changeset	634	begin
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	635	Land[cpY + y, cpX + x]:= lfObject;
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	636	if (cReducedQuality and rqBlurryLand) = 0 then
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	637	LandPixels[cpY + y, cpX + x]:= PLongword(@(p^[x * 4]))^
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	638	else
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	639	LandPixels[(cpY + y) div 2, (cpX + x) div 2]:= PLongword(@(p^[x * 4]))^
769 788efc1d649f - Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization unc0rr parents: 768 diff changeset	640	end;
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	641	p:= @(p^[Image^.pitch]);
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	642	end;
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	643	end;
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	644	if SDL_MustLock(Image) then
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	645	SDL_UnlockSurface(Image);
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	646
1807 795f97007833 Split land texture into small ones: unc0rr parents: 1806 diff changeset	647	x:= max(cpX, leftX);
795f97007833 Split land texture into small ones: unc0rr parents: 1806 diff changeset	648	w:= min(cpX + Image^.w, LAND_WIDTH) - x;
1792 c30c6944bd49 engine part of nemo's patch unc0rr parents: 1761 diff changeset	649	y:= max(cpY, topY);
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	650	h:= min(cpY + Image^.h, LAND_HEIGHT) - y;
1807 795f97007833 Split land texture into small ones: unc0rr parents: 1806 diff changeset	651	UpdateLandTexture(x, w, y, h)
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	652	end;
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	653
1738 00e8dadce69a Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays unc0rr parents: 1066 diff changeset	654	// was experimenting with applying as damage occurred.
00e8dadce69a Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays unc0rr parents: 1066 diff changeset	655	function Despeckle(X, Y: LongInt): boolean;
00e8dadce69a Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays unc0rr parents: 1066 diff changeset	656	var nx, ny, i, j, c: LongInt;
00e8dadce69a Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays unc0rr parents: 1066 diff changeset	657	begin
3521 96a502730e81 Remove redundant test, add some temp variables to speed up the expensive CheckLand nemo parents: 3519 diff changeset	658	if ((Land[Y, X] and lfDamaged) <> 0) and ((Land[Y, X] and lfIndestructible) = 0) then // check neighbours
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	659	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	660	c:= 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	661	for i:= -1 to 1 do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	662	for j:= -1 to 1 do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	663	if (i <> 0) or (j <> 0) then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	664	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	665	ny:= Y + i;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	666	nx:= X + j;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	667	if ((ny and LAND_HEIGHT_MASK) = 0) and ((nx and LAND_WIDTH_MASK) = 0) then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	668	if Land[ny, nx] > 255 then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	669	inc(c);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	670	end;
1738 00e8dadce69a Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays unc0rr parents: 1066 diff changeset	671
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	672	if c < 4 then // 0-3 neighbours
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	673	begin
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	674	if (cReducedQuality and rqBlurryLand) = 0 then
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	675	if (Land[Y, X] and lfBasic) <> 0 then
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	676	LandPixels[Y, X]:= LandBackPixel(X, Y)
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	677	else
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	678	LandPixels[Y, X]:= 0
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	679	else
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	680	if (Land[Y, X] and lfBasic) <> 0 then
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	681	LandPixels[Y div 2, X div 2]:= LandBackPixel(X, Y)
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	682	else
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	683	LandPixels[Y div 2, X div 2]:= 0;
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	684
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	685	Land[Y, X]:= 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	686	exit(true);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	687	end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	688	end;
1738 00e8dadce69a Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays unc0rr parents: 1066 diff changeset	689	Despeckle:= false
00e8dadce69a Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays unc0rr parents: 1066 diff changeset	690	end;
00e8dadce69a Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays unc0rr parents: 1066 diff changeset	691
1792 c30c6944bd49 engine part of nemo's patch unc0rr parents: 1761 diff changeset	692	function SweepDirty: boolean;
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	693	var x, y, xx, yy, ty, tx: LongInt;
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	694	bRes, updateBlock, resweep, recheck: boolean;
1738 00e8dadce69a Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays unc0rr parents: 1066 diff changeset	695	begin
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2666 diff changeset	696	bRes:= false;
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	697	reCheck:= true;
1792 c30c6944bd49 engine part of nemo's patch unc0rr parents: 1761 diff changeset	698
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	699	while recheck do
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	700	begin
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	701	recheck:= false;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	702	for y:= 0 to LAND_HEIGHT div 32 - 1 do
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	703	begin
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	704	for x:= 0 to LAND_WIDTH div 32 - 1 do
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	705	begin
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	706	if LandDirty[y, x] <> 0 then
2167 4e9ad395c1d1 Loop sweeping to avoid stray pixels. Avoided at first hoping there was a cleverer approach. Fortunately sweep is infrequent. nemo parents: 1892 diff changeset	707	begin
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	708	updateBlock:= false;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	709	resweep:= true;
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	710	ty:= y shl 5;
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	711	tx:= x shl 5;
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	712	while(resweep) do
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	713	begin
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	714	resweep:= false;
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	715	for yy:= ty to ty + 31 do
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	716	for xx:= tx to tx + 31 do
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	717	if Despeckle(xx, yy) then
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	718	begin
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	719	bRes:= true;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	720	updateBlock:= true;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	721	resweep:= true;
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	722	if (yy = ty) and (y > 0) then
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	723	begin
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	724	LandDirty[y-1, x]:= 1;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	725	recheck:= true;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	726	end
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	727	else if (yy = ty+31) and (y < LAND_HEIGHT div 32 - 1) then
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	728	begin
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	729	LandDirty[y+1, x]:= 1;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	730	recheck:= true;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	731	end;
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	732	if (xx = tx) and (x > 0) then
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	733	begin
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	734	LandDirty[y, x-1]:= 1;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	735	recheck:= true;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	736	end
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	737	else if (xx = tx+31) and (x < LAND_WIDTH div 32 - 1) then
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	738	begin
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	739	LandDirty[y, tx+1]:= 1;
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	740	recheck:= true;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	741	end
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	742	end;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	743	end;
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	744	if updateBlock then UpdateLandTexture(tx, 32, ty, 32);
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	745	LandDirty[y, x]:= 0;
2167 4e9ad395c1d1 Loop sweeping to avoid stray pixels. Avoided at first hoping there was a cleverer approach. Fortunately sweep is infrequent. nemo parents: 1892 diff changeset	746	end;
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	747	end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	748	end;
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	749	end;
1792 c30c6944bd49 engine part of nemo's patch unc0rr parents: 1761 diff changeset	750
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2666 diff changeset	751	SweepDirty:= bRes;
1738 00e8dadce69a Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays unc0rr parents: 1066 diff changeset	752	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	753
2331 e4941a7986d6 Another try at keeping blowtorch/firepunch/jackhammer from going through indestructible stuff. Shame these routines don't use hedgehog movement nemo parents: 2236 diff changeset	754	// Return true if outside of land or not the value tested, used right now for some X/Y movement that does not use normal hedgehog movement in GSHandlers.inc
3509 d72c2219595d Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag) nemo parents: 3236 diff changeset	755	function CheckLandValue(X, Y: LongInt; LandFlag: Word): boolean;
2331 e4941a7986d6 Another try at keeping blowtorch/firepunch/jackhammer from going through indestructible stuff. Shame these routines don't use hedgehog movement nemo parents: 2236 diff changeset	756	begin
3509 d72c2219595d Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag) nemo parents: 3236 diff changeset	757	CheckLandValue:= ((X and LAND_WIDTH_MASK <> 0) or (Y and LAND_HEIGHT_MASK <> 0)) or ((Land[Y, X] and LandFlag) = 0)
2331 e4941a7986d6 Another try at keeping blowtorch/firepunch/jackhammer from going through indestructible stuff. Shame these routines don't use hedgehog movement nemo parents: 2236 diff changeset	758	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	759	end.

author	nemo
	Wed, 30 Jun 2010 23:15:14 -0400
changeset 3596	51062794ed01
parent 3595	341e407e3754
child 3601	8a74c9ceaf71
permissions	-rw-r--r--