hedgewars: hedgewars/uLandGraphics.pas@e04da46ee43c (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
6700 e04da46ee43c the most important commit of the year koda parents: 6681 diff changeset	3	* Copyright (c) 2004-2012 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
4357 a1fcfc341a52 Introduce unit uTypes in order to remove some cyclic unit dependencies unC0Rr parents: 3749 diff changeset	23	uses uFloat, uConsts, uTypes;
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
4791 458d9854c679 Snow blends into land, trys to fill the gaps Palewolf parents: 4700 diff changeset	30	function addBgColor(OldColor, NewColor: LongWord): LongWord;
2716 b9ca1bfca24f complete the replacement of init/free wrappers for every unit koda parents: 2695 diff changeset	31	function SweepDirty: boolean;
5885 ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	32	function Despeckle(X, Y: LongInt): Boolean;
5267 e9ae019e9bb4 move smoothing into separate function, adjust call order nemo parents: 5266 diff changeset	33	procedure Smooth(X, Y: LongInt);
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	34	function CheckLandValue(X, Y: LongInt; LandFlag: Word): boolean;
4377 43945842da0c Haven't found a better place than uIO for OutError unC0Rr parents: 4374 diff changeset	35	function DrawExplosion(X, Y, Radius: LongInt): Longword;
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	36	procedure DrawHLinesExplosions(ar: PRangeArray; Radius: LongInt; y, dY: LongInt; Count: Byte);
731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	37	procedure DrawTunnel(X, Y, dX, dY: hwFloat; ticks, HalfWidth: LongInt);
731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	38	procedure FillRoundInLand(X, Y, Radius: LongInt; Value: Longword);
511 2b5b9e00419d - Further work on new collisions implementation unc0rr parents: 505 diff changeset	39	procedure ChangeRoundInLand(X, Y, Radius: LongInt; doSet: boolean);
4367 f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	40	function LandBackPixel(x, y: LongInt): LongWord;
6490 531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	41	procedure DrawLine(X1, Y1, X2, Y2: LongInt; Color: Longword);
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	42
4886 e3e5362a308e fixed unlimeted fuel bug for rcplane Henek parents: 4791 diff changeset	43	function TryPlaceOnLand(cpX, cpY: LongInt; Obj: TSprite; Frame: LongInt; doPlace: boolean; indestructible: boolean): boolean;
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	44
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	45	implementation
4403 0dfe26f48ec1 uDebug unc0rr parents: 4377 diff changeset	46	uses SDLh, uLandTexture, uVariables, uUtils, uDebug;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	47
4791 458d9854c679 Snow blends into land, trys to fill the gaps Palewolf parents: 4700 diff changeset	48	function addBgColor(OldColor, NewColor: LongWord): LongWord;
458d9854c679 Snow blends into land, trys to fill the gaps Palewolf parents: 4700 diff changeset	49	// Factor ranges from 0 to 100% NewColor
458d9854c679 Snow blends into land, trys to fill the gaps Palewolf parents: 4700 diff changeset	50	var
6011 519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code) unC0Rr parents: 5895 diff changeset	51	oRed, oBlue, oGreen, oAlpha, nRed, nBlue, nGreen, nAlpha: byte;
4791 458d9854c679 Snow blends into land, trys to fill the gaps Palewolf parents: 4700 diff changeset	52	begin
6011 519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code) unC0Rr parents: 5895 diff changeset	53	oAlpha := (OldColor shr AShift);
519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code) unC0Rr parents: 5895 diff changeset	54	nAlpha := (NewColor shr AShift);
5692 753ae5d0776c implement proper blending nemo parents: 5687 diff changeset	55	// shortcircuit
753ae5d0776c implement proper blending nemo parents: 5687 diff changeset	56	if (oAlpha = 0) or (nAlpha = $FF) then
753ae5d0776c implement proper blending nemo parents: 5687 diff changeset	57	begin
753ae5d0776c implement proper blending nemo parents: 5687 diff changeset	58	addBgColor:= NewColor;
753ae5d0776c implement proper blending nemo parents: 5687 diff changeset	59	exit
753ae5d0776c implement proper blending nemo parents: 5687 diff changeset	60	end;
4791 458d9854c679 Snow blends into land, trys to fill the gaps Palewolf parents: 4700 diff changeset	61	// Get colors
6011 519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code) unC0Rr parents: 5895 diff changeset	62	oRed := (OldColor shr RShift);
519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code) unC0Rr parents: 5895 diff changeset	63	oGreen := (OldColor shr GShift);
519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code) unC0Rr parents: 5895 diff changeset	64	oBlue := (OldColor shr BShift);
4791 458d9854c679 Snow blends into land, trys to fill the gaps Palewolf parents: 4700 diff changeset	65
6011 519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code) unC0Rr parents: 5895 diff changeset	66	nRed := (NewColor shr RShift);
519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code) unC0Rr parents: 5895 diff changeset	67	nGreen := (NewColor shr GShift);
519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code) unC0Rr parents: 5895 diff changeset	68	nBlue := (NewColor shr BShift);
4791 458d9854c679 Snow blends into land, trys to fill the gaps Palewolf parents: 4700 diff changeset	69
458d9854c679 Snow blends into land, trys to fill the gaps Palewolf parents: 4700 diff changeset	70	// Mix colors
6011 519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code) unC0Rr parents: 5895 diff changeset	71	nRed := min(255,((nRednAlpha) div 255) + ((oRedoAlpha*byte(255-nAlpha)) div 65025));
519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code) unC0Rr parents: 5895 diff changeset	72	nGreen := min(255,((nGreennAlpha) div 255) + ((oGreenoAlpha*byte(255-nAlpha)) div 65025));
519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code) unC0Rr parents: 5895 diff changeset	73	nBlue := min(255,((nBluenAlpha) div 255) + ((oBlueoAlpha*byte(255-nAlpha)) div 65025));
4791 458d9854c679 Snow blends into land, trys to fill the gaps Palewolf parents: 4700 diff changeset	74	nAlpha := min(255, oAlpha + nAlpha);
458d9854c679 Snow blends into land, trys to fill the gaps Palewolf parents: 4700 diff changeset	75
5041 3dc6ad20cbfe Fix endianness nemo parents: 4976 diff changeset	76	addBgColor := (nAlpha shl AShift) or (nRed shl RShift) or (nGreen shl GShift) or (nBlue shl BShift);
4791 458d9854c679 Snow blends into land, trys to fill the gaps Palewolf parents: 4700 diff changeset	77	end;
458d9854c679 Snow blends into land, trys to fill the gaps Palewolf parents: 4700 diff changeset	78
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	79	procedure FillCircleLines(x, y, dx, dy: LongInt; Value: Longword);
731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	80	var i: LongInt;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	81	begin
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	82	if ((y + dy) and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	83	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	84	if (Land[y + dy, i] and lfIndestructible) = 0 then
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	85	Land[y + dy, i]:= Value;
2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	86	if ((y - dy) and LAND_HEIGHT_MASK) = 0 then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	87	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	88	if (Land[y - dy, i] and lfIndestructible) = 0 then
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	89	Land[y - dy, i]:= Value;
2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	90	if ((y + dx) and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	91	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	92	if (Land[y + dx, i] and lfIndestructible) = 0 then
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	93	Land[y + dx, i]:= Value;
2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	94	if ((y - dx) and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	95	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	96	if (Land[y - dx, i] and lfIndestructible) = 0 then
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	97	Land[y - dx, i]:= Value;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	98	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	99
511 2b5b9e00419d - Further work on new collisions implementation unc0rr parents: 505 diff changeset	100	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	101	var i: LongInt;
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	102	begin
511 2b5b9e00419d - Further work on new collisions implementation unc0rr parents: 505 diff changeset	103	if not doSet then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	104	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	105	if ((y + dy) and LAND_HEIGHT_MASK) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	106	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	107	if (Land[y + dy, i] > 0) and (Land[y + dy, i] < 256) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	108	dec(Land[y + dy, i]); // check > 0 because explosion can erase collision data
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	109	if ((y - dy) and LAND_HEIGHT_MASK) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	110	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	111	if (Land[y - dy, i] > 0) and (Land[y - dy, i] < 256) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	112	dec(Land[y - dy, i]);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	113	if ((y + dx) and LAND_HEIGHT_MASK) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	114	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	115	if (Land[y + dx, i] > 0) and (Land[y + dx, i] < 256) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	116	dec(Land[y + dx, i]);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	117	if ((y - dx) and LAND_HEIGHT_MASK) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	118	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	119	if (Land[y - dx, i] > 0) and (Land[y - dx, i] < 256) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	120	dec(Land[y - dx, i]);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	121	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	122	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	123	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	124	if ((y + dy) and LAND_HEIGHT_MASK) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	125	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	126	if (Land[y + dy, i] < 256) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	127	inc(Land[y + dy, i]);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	128	if ((y - dy) and LAND_HEIGHT_MASK) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	129	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	130	if (Land[y - dy, i] < 256) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	131	inc(Land[y - dy, i]);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	132	if ((y + dx) and LAND_HEIGHT_MASK) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	133	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	134	if (Land[y + dx, i] < 256) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	135	inc(Land[y + dx, i]);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	136	if ((y - dx) and LAND_HEIGHT_MASK) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	137	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	138	if (Land[y - dx, i] < 256) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	139	inc(Land[y - dx, i]);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	140	end
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
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	143	procedure FillRoundInLand(X, Y, Radius: LongInt; Value: Longword);
731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	144	var dx, dy, d: LongInt;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	145	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	146	dx:= 0;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	147	dy:= Radius;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	148	d:= 3 - 2 * Radius;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	149	while (dx < dy) do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	150	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	151	FillCircleLines(x, y, dx, dy, Value);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	152	if (d < 0) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	153	d:= d + 4 * dx + 6
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	154	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	155	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	156	d:= d + 4 * (dx - dy) + 10;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	157	dec(dy)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	158	end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	159	inc(dx)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	160	end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	161	if (dx = dy) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	162	FillCircleLines(x, y, dx, dy, Value);
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	163	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	164
511 2b5b9e00419d - Further work on new collisions implementation unc0rr parents: 505 diff changeset	165	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	166	var dx, dy, d: LongInt;
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	167	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	168	dx:= 0;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	169	dy:= Radius;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	170	d:= 3 - 2 * Radius;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	171	while (dx < dy) do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	172	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	173	ChangeCircleLines(x, y, dx, dy, doSet);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	174	if (d < 0) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	175	d:= d + 4 * dx + 6
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	176	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	177	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	178	d:= d + 4 * (dx - dy) + 10;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	179	dec(dy)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	180	end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	181	inc(dx)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	182	end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	183	if (dx = dy) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	184	ChangeCircleLines(x, y, dx, dy, doSet)
504 13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	185	end;
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	186
2603 abed6070a669 revert previous commit to remove a wip patch koda parents: 2602 diff changeset	187	procedure FillLandCircleLines0(x, y, dx, dy: LongInt);
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	188	var i, t: LongInt;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	189	begin
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	190	t:= y + dy;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	191	if (t and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	192	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
6096 a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	193	if ((Land[t, i] and lfIndestructible) = 0) and (not disableLandBack or (Land[t, i] > 255)) 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	194	if (cReducedQuality and rqBlurryLand) = 0 then
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	195	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	196	else
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	197	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	198
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	199	t:= y - dy;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	200	if (t and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	201	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
6096 a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	202	if ((Land[t, i] and lfIndestructible) = 0) and (not disableLandBack or (Land[t, i] > 255)) 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	203	if (cReducedQuality and rqBlurryLand) = 0 then
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	204	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	205	else
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	206	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	207
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	208	t:= y + dx;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	209	if (t and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	210	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
6096 a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	211	if ((Land[t, i] and lfIndestructible) = 0) and (not disableLandBack or (Land[t, i] > 255)) 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
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 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
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 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
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	217	t:= y - dx;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	218	if (t and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	219	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
6096 a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	220	if ((Land[t, i] and lfIndestructible) = 0) and (not disableLandBack or (Land[t, i] > 255)) 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
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	222	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	223	else
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	224	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	225
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	226	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	227
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	228	function FillLandCircleLinesBG(x, y, dx, dy: LongInt): Longword;
5480 37bafa5a7016 kill off some speckles, crank up land gun output nemo parents: 5386 diff changeset	229	var i, t, by, bx: LongInt;
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	230	cnt: Longword;
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	231	begin
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	232	cnt:= 0;
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	233	t:= y + dy;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	234	if (t and LAND_HEIGHT_MASK) = 0 then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	235	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	236	if (Land[t, i] and lfIndestructible) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	237	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	238	if (cReducedQuality and rqBlurryLand) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	239	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	240	by:= t; bx:= i;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	241	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	242	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	243	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	244	by:= t div 2; bx:= i div 2;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	245	end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	246	if ((Land[t, i] and lfBasic) <> 0) and (((LandPixels[by,bx] and AMask) shr AShift) = 255) and (not disableLandBack) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	247	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	248	inc(cnt);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	249	LandPixels[by, bx]:= LandBackPixel(i, t)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	250	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	251	else if ((Land[t, i] and lfObject) <> 0) or (((LandPixels[by,bx] and AMask) shr AShift) < 255) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	252	LandPixels[by, bx]:= 0
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	253	end;
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	254
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	255	t:= y - dy;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	256	if (t and LAND_HEIGHT_MASK) = 0 then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	257	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	258	if (Land[t, i] and lfIndestructible) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	259	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	260	if (cReducedQuality and rqBlurryLand) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	261	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	262	by:= t; bx:= i;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	263	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	264	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	265	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	266	by:= t div 2; bx:= i div 2;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	267	end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	268	if ((Land[t, i] and lfBasic) <> 0) and (((LandPixels[by,bx] and AMask) shr AShift) = 255) and (not disableLandBack) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	269	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	270	inc(cnt);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	271	LandPixels[by, bx]:= LandBackPixel(i, t)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	272	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	273	else if ((Land[t, i] and lfObject) <> 0) or (((LandPixels[by,bx] and AMask) shr AShift) < 255) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	274	LandPixels[by, bx]:= 0
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	275	end;
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	276
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	277	t:= y + dx;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	278	if (t and LAND_HEIGHT_MASK) = 0 then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	279	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	280	if (Land[t, i] and lfIndestructible) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	281	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	282	if (cReducedQuality and rqBlurryLand) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	283	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	284	by:= t; bx:= i;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	285	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	286	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	287	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	288	by:= t div 2; bx:= i div 2;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	289	end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	290	if ((Land[t, i] and lfBasic) <> 0) and (((LandPixels[by,bx] and AMask) shr AShift) = 255) and (not disableLandBack) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	291	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	292	inc(cnt);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	293	LandPixels[by, bx]:= LandBackPixel(i, t)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	294	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	295	else if ((Land[t, i] and lfObject) <> 0) or (((LandPixels[by,bx] and AMask) shr AShift) < 255) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	296	LandPixels[by, bx]:= 0
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	297	end;
4695 ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	298	t:= y - dx;
ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	299	if (t and LAND_HEIGHT_MASK) = 0 then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	300	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	301	if (Land[t, i] and lfIndestructible) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	302	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	303	if (cReducedQuality and rqBlurryLand) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	304	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	305	by:= t; bx:= i;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	306	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	307	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	308	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	309	by:= t div 2; bx:= i div 2;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	310	end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	311	if ((Land[t, i] and lfBasic) <> 0) and (((LandPixels[by,bx] and AMask) shr AShift) = 255) and (not disableLandBack) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	312	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	313	inc(cnt);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	314	LandPixels[by, bx]:= LandBackPixel(i, t)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	315	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	316	else if ((Land[t, i] and lfObject) <> 0) or (((LandPixels[by,bx] and AMask) shr AShift) < 255) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	317	LandPixels[by, bx]:= 0
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	318	end;
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	319	FillLandCircleLinesBG:= cnt;
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	320	end;
0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	321
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	322	procedure FillLandCircleLinesEBC(x, y, dx, dy: LongInt);
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	323	var i, t: LongInt;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	324	begin
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	325	t:= y + dy;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	326	if (t and LAND_HEIGHT_MASK) = 0 then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	327	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	328	if ((Land[t, i] and lfBasic) <> 0) or ((Land[t, i] and lfObject) <> 0) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	329	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	330	if (cReducedQuality and rqBlurryLand) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	331	LandPixels[t, i]:= cExplosionBorderColor
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	332	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	333	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	334
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	335	Land[t, i]:= Land[t, i] or lfDamaged;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	336	//Despeckle(i, t);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	337	LandDirty[t div 32, i div 32]:= 1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	338	end;
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	339
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	340	t:= y - dy;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	341	if (t and LAND_HEIGHT_MASK) = 0 then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	342	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	343	if ((Land[t, i] and lfBasic) <> 0) or ((Land[t, i] and lfObject) <> 0) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	344	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	345	if (cReducedQuality and rqBlurryLand) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	346	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	347	else
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	348	LandPixels[t div 2, i div 2]:= cExplosionBorderColor;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	349	Land[t, i]:= Land[t, i] or lfDamaged;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	350	//Despeckle(i, t);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	351	LandDirty[t div 32, i div 32]:= 1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	352	end;
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	353
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	354	t:= y + dx;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	355	if (t and LAND_HEIGHT_MASK) = 0 then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	356	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	357	if ((Land[t, i] and lfBasic) <> 0) or ((Land[t, i] and lfObject) <> 0) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	358	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	359	if (cReducedQuality and rqBlurryLand) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	360	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	361	else
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	362	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	363
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	364	Land[t, i]:= Land[t, i] or lfDamaged;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	365	//Despeckle(i, t);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	366	LandDirty[t div 32, i div 32]:= 1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	367	end;
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	368
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	369	t:= y - dx;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	370	if (t and LAND_HEIGHT_MASK) = 0 then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	371	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	372	if ((Land[t, i] and lfBasic) <> 0) or ((Land[t, i] and lfObject) <> 0) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	373	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	374	if (cReducedQuality and rqBlurryLand) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	375	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	376	else
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	377	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	378
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	379	Land[t, i]:= Land[t, i] or lfDamaged;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	380	//Despeckle(i, y - dy);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	381	LandDirty[t div 32, i div 32]:= 1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	382	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	383	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	384
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	385	function DrawExplosion(X, Y, Radius: LongInt): Longword;
2603 abed6070a669 revert previous commit to remove a wip patch koda parents: 2602 diff changeset	386	var dx, dy, ty, tx, d: LongInt;
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	387	cnt: Longword;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	388	begin
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	389
0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	390	// draw background land texture
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	391	begin
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	392	cnt:= 0;
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	393	dx:= 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	394	dy:= Radius;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	395	d:= 3 - 2 * Radius;
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	396
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	397	while (dx < dy) do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	398	begin
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	399	inc(cnt, FillLandCircleLinesBG(x, y, dx, dy));
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	400	if (d < 0) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	401	d:= d + 4 * dx + 6
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	402	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	403	begin
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	404	d:= d + 4 * (dx - dy) + 10;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	405	dec(dy)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	406	end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	407	inc(dx)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	408	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	409	if (dx = dy) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	410	inc(cnt, FillLandCircleLinesBG(x, y, dx, dy));
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	411	end;
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	412
0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	413	// draw a hole in land
2733 52a5a160566f Engine: smxx parents: 2716 diff changeset	414	if Radius > 20 then
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	415	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	416	dx:= 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	417	dy:= Radius - 15;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	418	d:= 3 - 2 * dy;
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	419
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	420	while (dx < dy) do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	421	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	422	FillLandCircleLines0(x, y, dx, dy);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	423	if (d < 0) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	424	d:= d + 4 * dx + 6
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	425	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	426	begin
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	427	d:= d + 4 * (dx - dy) + 10;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	428	dec(dy)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	429	end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	430	inc(dx)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	431	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	432	if (dx = dy) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	433	FillLandCircleLines0(x, y, dx, dy);
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	434	end;
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	435
1849 2a989e5abda6 4 utilities by nemo unc0rr parents: 1809 diff changeset	436	// 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	437	FillRoundInLand(X, Y, Radius, 0);
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	438
0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	439	// draw explosion border
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	440	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	441	inc(Radius, 4);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	442	dx:= 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	443	dy:= Radius;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	444	d:= 3 - 2 * Radius;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	445	while (dx < dy) do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	446	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	447	FillLandCircleLinesEBC(x, y, dx, dy);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	448	if (d < 0) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	449	d:= d + 4 * dx + 6
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	450	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	451	begin
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	452	d:= d + 4 * (dx - dy) + 10;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	453	dec(dy)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	454	end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	455	inc(dx)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	456	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	457	if (dx = dy) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	458	FillLandCircleLinesEBC(x, y, dx, dy);
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	459	end;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 345 diff changeset	460
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	461	tx:= Max(X - Radius - 1, 0);
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	462	dx:= Min(X + Radius + 1, LAND_WIDTH) - tx;
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	463	ty:= Max(Y - Radius - 1, 0);
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	464	dy:= Min(Y + Radius + 1, LAND_HEIGHT) - ty;
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	465	UpdateLandTexture(tx, dx, ty, dy);
e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	466	DrawExplosion:= cnt
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	467	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	468
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	469	procedure DrawHLinesExplosions(ar: PRangeArray; Radius: LongInt; y, dY: LongInt; Count: Byte);
5480 37bafa5a7016 kill off some speckles, crank up land gun output nemo parents: 5386 diff changeset	470	var tx, ty, by, bx, i: LongInt;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	471	begin
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	472	for i:= 0 to Pred(Count) do
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	473	begin
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	474	for ty:= Max(y - Radius, 0) to Min(y + Radius, LAND_HEIGHT) do
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	475	for tx:= Max(0, ar^[i].Left - Radius) to Min(LAND_WIDTH, ar^[i].Right + Radius) do
5480 37bafa5a7016 kill off some speckles, crank up land gun output nemo parents: 5386 diff changeset	476	begin
6096 a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	477	if (Land[ty, tx] and lfIndestructible) = 0 then
5480 37bafa5a7016 kill off some speckles, crank up land gun output nemo parents: 5386 diff changeset	478	begin
6096 a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	479	if (cReducedQuality and rqBlurryLand) = 0 then
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	480	begin
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	481	by:= ty; bx:= tx;
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	482	end
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	483	else
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	484	begin
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	485	by:= ty div 2; bx:= tx div 2;
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	486	end;
6355 734fed7aefd3 Introduce initialization expressions unc0rr parents: 6132 diff changeset	487	if ((Land[ty, tx] and lfBasic) <> 0) and (((LandPixels[by,bx] and AMask) shr AShift) = 255) and (not disableLandBack) then
6096 a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	488	LandPixels[by, bx]:= LandBackPixel(tx, ty)
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	489	else if ((Land[ty, tx] and lfObject) <> 0) or (((LandPixels[by,bx] and AMask) shr AShift) < 255) then
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	490	LandPixels[by, bx]:= 0
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	491	end
5480 37bafa5a7016 kill off some speckles, crank up land gun output nemo parents: 5386 diff changeset	492	end;
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	493	inc(y, dY)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	494	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	495
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	496	inc(Radius, 4);
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 345 diff changeset	497	dec(y, Count * dY);
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	498
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	499	for i:= 0 to Pred(Count) do
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	500	begin
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	501	for ty:= Max(y - Radius, 0) to Min(y + Radius, LAND_HEIGHT) do
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	502	for tx:= Max(0, ar^[i].Left - Radius) to Min(LAND_WIDTH, ar^[i].Right + Radius) do
4690 490cf71b436a revert last change. ordinary fire is fine, but HHG screws up. nemo parents: 4688 diff changeset	503	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	504	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	505	if (cReducedQuality and rqBlurryLand) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	506	LandPixels[ty, tx]:= cExplosionBorderColor
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	507	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	508	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	509
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	510	Land[ty, tx]:= Land[ty, tx] or lfDamaged;
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	511	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	512	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	513	inc(y, dY)
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	514	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	515
818 635e58295079 Fix drill bug unc0rr parents: 772 diff changeset	516
1807 795f97007833 Split land texture into small ones: unc0rr parents: 1806 diff changeset	517	UpdateLandTexture(0, LAND_WIDTH, 0, LAND_HEIGHT)
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	518	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	519
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	520	//
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	521	// - (dX, dY) - direction, vector of length = 0.5
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	522	//
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	523	procedure DrawTunnel(X, Y, dX, dY: hwFloat; ticks, HalfWidth: LongInt);
358 236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	524	var nx, ny, dX8, dY8: hwFloat;
5480 37bafa5a7016 kill off some speckles, crank up land gun output nemo parents: 5386 diff changeset	525	i, t, tx, ty, by, bx, stX, stY, ddy, ddx: Longint;
5332 b29d60c7cac7 Use an ifdef instead, add despeckling of tunnels nemo parents: 5322 diff changeset	526	despeckle : Boolean;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	527	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	528	stY:= hwRound(Y);
1809 77923087a1ce Some optimization of land texture updating unc0rr parents: 1807 diff changeset	529	stX:= hwRound(X);
772 e8d530ca77be Don't update all land texture when drawing tunnel (saves video throughput) unc0rr parents: 769 diff changeset	530
5332 b29d60c7cac7 Use an ifdef instead, add despeckling of tunnels nemo parents: 5322 diff changeset	531	despeckle:= HalfWidth > 1;
b29d60c7cac7 Use an ifdef instead, add despeckling of tunnels nemo parents: 5322 diff changeset	532
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	533	nx:= X + dY * (HalfWidth + 8);
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	534	ny:= Y - dX * (HalfWidth + 8);
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	535
358 236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	536	dX8:= dX * 8;
236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	537	dY8:= dY * 8;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	538	for i:= 0 to 7 do
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	539	begin
358 236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	540	X:= nx - dX8;
236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	541	Y:= ny - dY8;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	542	for t:= -8 to ticks + 8 do
2666 2b8c8f16421e update SDLMain.m/.h to latest version koda parents: 2648 diff changeset	543	begin
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	544	X:= X + dX;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	545	Y:= Y + dY;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	546	tx:= hwRound(X);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	547	ty:= hwRound(Y);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	548	if ((ty and LAND_HEIGHT_MASK) = 0)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	549	and ((tx and LAND_WIDTH_MASK) = 0)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	550	and (((Land[ty, tx] and lfBasic) <> 0) or ((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	551	begin
5887 7d69b76ce923 Don't set lfDamaged for small tunnels nemo parents: 5885 diff changeset	552	if despeckle then
7d69b76ce923 Don't set lfDamaged for small tunnels nemo parents: 5885 diff changeset	553	begin
7d69b76ce923 Don't set lfDamaged for small tunnels nemo parents: 5885 diff changeset	554	Land[ty, tx]:= Land[ty, tx] or lfDamaged;
7d69b76ce923 Don't set lfDamaged for small tunnels nemo parents: 5885 diff changeset	555	LandDirty[ty div 32, tx div 32]:= 1
7d69b76ce923 Don't set lfDamaged for small tunnels nemo parents: 5885 diff changeset	556	end;
5332 b29d60c7cac7 Use an ifdef instead, add despeckling of tunnels nemo parents: 5322 diff changeset	557	if (cReducedQuality and rqBlurryLand) = 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	558	LandPixels[ty, tx]:= cExplosionBorderColor
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	559	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	560	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	561	end
2666 2b8c8f16421e update SDLMain.m/.h to latest version koda parents: 2648 diff changeset	562	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	563	nx:= nx - dY;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	564	ny:= ny + dX;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	565	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	566
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	567	for i:= -HalfWidth to HalfWidth do
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	568	begin
358 236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	569	X:= nx - dX8;
236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	570	Y:= ny - dY8;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	571	for t:= 0 to 7 do
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	572	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	573	X:= X + dX;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	574	Y:= Y + dY;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	575	tx:= hwRound(X);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	576	ty:= hwRound(Y);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	577	if ((ty and LAND_HEIGHT_MASK) = 0) and ((tx and LAND_WIDTH_MASK) = 0) and (((Land[ty, tx] and lfBasic) <> 0)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	578	or ((Land[ty, tx] and lfObject) <> 0)) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	579	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	580	Land[ty, tx]:= Land[ty, tx] or lfDamaged;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	581	if despeckle then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	582	LandDirty[ty div 32, tx div 32]:= 1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	583	if (cReducedQuality and rqBlurryLand) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	584	LandPixels[ty, tx]:= cExplosionBorderColor
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	585	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	586	LandPixels[ty div 2, tx div 2]:= cExplosionBorderColor
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	587	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	588	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	589	X:= nx;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	590	Y:= ny;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	591	for t:= 0 to ticks do
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	592	begin
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	593	X:= X + dX;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	594	Y:= Y + dY;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 345 diff changeset	595	tx:= hwRound(X);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 345 diff changeset	596	ty:= hwRound(Y);
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	597	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	598	begin
5480 37bafa5a7016 kill off some speckles, crank up land gun output nemo parents: 5386 diff changeset	599	if (cReducedQuality and rqBlurryLand) = 0 then
37bafa5a7016 kill off some speckles, crank up land gun output nemo parents: 5386 diff changeset	600	begin
37bafa5a7016 kill off some speckles, crank up land gun output nemo parents: 5386 diff changeset	601	by:= ty; bx:= tx;
37bafa5a7016 kill off some speckles, crank up land gun output nemo parents: 5386 diff changeset	602	end
4690 490cf71b436a revert last change. ordinary fire is fine, but HHG screws up. nemo parents: 4688 diff changeset	603	else
5480 37bafa5a7016 kill off some speckles, crank up land gun output nemo parents: 5386 diff changeset	604	begin
37bafa5a7016 kill off some speckles, crank up land gun output nemo parents: 5386 diff changeset	605	by:= ty div 2; bx:= tx div 2;
37bafa5a7016 kill off some speckles, crank up land gun output nemo parents: 5386 diff changeset	606	end;
6355 734fed7aefd3 Introduce initialization expressions unc0rr parents: 6132 diff changeset	607	if ((Land[ty, tx] and lfBasic) <> 0) and (((LandPixels[by,bx] and AMask) shr AShift) = 255) and (not disableLandBack) then
6096 a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	608	LandPixels[by, bx]:= LandBackPixel(tx, ty)
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	609	else if ((Land[ty, tx] and lfObject) <> 0) or (((LandPixels[by,bx] and AMask) shr AShift) < 255) then
6097 db10abae541f Couple more, add back misplaced clearing of Land nemo parents: 6096 diff changeset	610	LandPixels[by, bx]:= 0;
db10abae541f Couple more, add back misplaced clearing of Land nemo parents: 6096 diff changeset	611	Land[ty, tx]:= 0;
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	612	end
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	613	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	614	for t:= 0 to 7 do
2666 2b8c8f16421e update SDLMain.m/.h to latest version koda parents: 2648 diff changeset	615	begin
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	616	X:= X + dX;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	617	Y:= Y + dY;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	618	tx:= hwRound(X);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	619	ty:= hwRound(Y);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	620	if ((ty and LAND_HEIGHT_MASK) = 0) and ((tx and LAND_WIDTH_MASK) = 0) and (((Land[ty, tx] and lfBasic) <> 0)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	621	or ((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	622	begin
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	623	Land[ty, tx]:= Land[ty, tx] or lfDamaged;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	624	if despeckle then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	625	LandDirty[ty div 32, tx div 32]:= 1;
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	626	if (cReducedQuality and rqBlurryLand) = 0 then
5332 b29d60c7cac7 Use an ifdef instead, add despeckling of tunnels nemo parents: 5322 diff changeset	627	LandPixels[ty, tx]:= cExplosionBorderColor
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	628	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	629	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	630	end
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	631	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	632	nx:= nx - dY;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	633	ny:= ny + dX;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	634	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	635
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	636	for i:= 0 to 7 do
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	637	begin
358 236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	638	X:= nx - dX8;
236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	639	Y:= ny - dY8;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	640	for t:= -8 to ticks + 8 do
2666 2b8c8f16421e update SDLMain.m/.h to latest version koda parents: 2648 diff changeset	641	begin
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	642	X:= X + dX;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	643	Y:= Y + dY;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	644	tx:= hwRound(X);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	645	ty:= hwRound(Y);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	646	if ((ty and LAND_HEIGHT_MASK) = 0) and ((tx and LAND_WIDTH_MASK) = 0) and (((Land[ty, tx] and lfBasic) <> 0)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	647	or ((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	648	begin
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	649	Land[ty, tx]:= Land[ty, tx] or lfDamaged;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	650	if despeckle then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	651	LandDirty[ty div 32, tx div 32]:= 1;
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	652	if (cReducedQuality and rqBlurryLand) = 0 then
5332 b29d60c7cac7 Use an ifdef instead, add despeckling of tunnels nemo parents: 5322 diff changeset	653	LandPixels[ty, tx]:= cExplosionBorderColor
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	654	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	655	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	656	end
2666 2b8c8f16421e update SDLMain.m/.h to latest version koda parents: 2648 diff changeset	657	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	658	nx:= nx - dY;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	659	ny:= ny + dX;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	660	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	661
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	662	tx:= Max(stX - HalfWidth * 2 - 4 - abs(hwRound(dX * ticks)), 0);
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	663	ty:= Max(stY - HalfWidth * 2 - 4 - abs(hwRound(dY * ticks)), 0);
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	664	ddx:= Min(stX + HalfWidth * 2 + 4 + abs(hwRound(dX * ticks)), LAND_WIDTH) - tx;
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	665	ddy:= Min(stY + HalfWidth * 2 + 4 + abs(hwRound(dY * ticks)), LAND_HEIGHT) - ty;
1809 77923087a1ce Some optimization of land texture updating unc0rr parents: 1807 diff changeset	666
77923087a1ce Some optimization of land texture updating unc0rr parents: 1807 diff changeset	667	UpdateLandTexture(tx, ddx, ty, ddy)
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	668	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	669
4886 e3e5362a308e fixed unlimeted fuel bug for rcplane Henek parents: 4791 diff changeset	670	function TryPlaceOnLand(cpX, cpY: LongInt; Obj: TSprite; Frame: LongInt; doPlace: boolean; indestructible: boolean): boolean;
6077 d8fa5a85d24f This prevents girders from erasing landbacktex (square windows in tunnels and such), at the cost of requiring lfBasic and lfObject to be treated the same apart from graphically nemo parents: 6011 diff changeset	671	var X, Y, bpp, h, w, row, col, gx, gy, numFramesFirstCol: LongInt;
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	672	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	673	Image: PSDL_Surface;
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	674	begin
2235 79c9542c1058 multi-column support nemo parents: 2167 diff changeset	675	numFramesFirstCol:= SpritesData[Obj].imageHeight div SpritesData[Obj].Height;
79c9542c1058 multi-column support nemo parents: 2167 diff changeset	676
769 788efc1d649f - Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization unc0rr parents: 768 diff changeset	677	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	678	Image:= SpritesData[Obj].Surface;
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	679	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	680	h:= SpritesData[Obj].Height;
2235 79c9542c1058 multi-column support nemo parents: 2167 diff changeset	681	row:= Frame mod numFramesFirstCol;
79c9542c1058 multi-column support nemo parents: 2167 diff changeset	682	col:= Frame div numFramesFirstCol;
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	683
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	684	if SDL_MustLock(Image) then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	685	SDLTry(SDL_LockSurface(Image) >= 0, true);
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	686
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	687	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	688	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	689	// Check that sprite fits free space
2236 af8fc3311748 the -1 was a bad idea nemo parents: 2235 diff changeset	690	p:= @(PByteArray(Image^.pixels)^[ Image^.pitch * row * h + col * w * 4 ]);
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	691	case bpp of
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	692	4: for y:= 0 to Pred(h) do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	693	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	694	for x:= 0 to Pred(w) do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	695	if (PLongword(@(p^[x * 4]))^) <> 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	696	if ((cpY + y) <= Longint(topY)) or ((cpY + y) >= LAND_HEIGHT)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	697	or ((cpX + x) <= Longint(leftX)) or ((cpX + x) >= Longint(rightX)) or (Land[cpY + y, cpX + x] <> 0) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	698	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	699	if SDL_MustLock(Image) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	700	SDL_UnlockSurface(Image);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	701	exit(false)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	702	end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	703	p:= @(p^[Image^.pitch]);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	704	end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	705	end;
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	706
520 e83dfb7ffead Teleportation tool unc0rr parents: 511 diff changeset	707	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	708	if not doPlace then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	709	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	710	if SDL_MustLock(Image) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	711	SDL_UnlockSurface(Image);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	712	exit
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	713	end;
520 e83dfb7ffead Teleportation tool unc0rr parents: 511 diff changeset	714
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	715	// Checked, now place
2236 af8fc3311748 the -1 was a bad idea nemo parents: 2235 diff changeset	716	p:= @(PByteArray(Image^.pixels)^[ Image^.pitch * row * h + col * w * 4 ]);
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	717	case bpp of
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	718	4: for y:= 0 to Pred(h) do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	719	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	720	for x:= 0 to Pred(w) do
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	721	if (PLongword(@(p^[x * 4]))^) <> 0 then
769 788efc1d649f - Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization unc0rr parents: 768 diff changeset	722	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	723	if (cReducedQuality and rqBlurryLand) = 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	724	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	725	gX:= cpX + x;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	726	gY:= cpY + y;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	727	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	728	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	729	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	730	gX:= (cpX + x) div 2;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	731	gY:= (cpY + y) div 2;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	732	end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	733	if indestructible then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	734	Land[cpY + y, cpX + x]:= lfIndestructible
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	735	else if (LandPixels[gY, gX] and AMask) shr AShift = 255 then // This test assumes lfBasic and lfObject differ only graphically
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	736	Land[cpY + y, cpX + x]:= lfBasic
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	737	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	738	Land[cpY + y, cpX + x]:= lfObject;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	739	// For testing only. Intent is to flag this on objects with masks, or use it for an ice ray gun
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	740	if (Theme = 'Snow') or (Theme = 'Christmas') then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	741	Land[cpY + y, cpX + x]:= Land[cpY + y, cpX + x] or lfIce;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	742	LandPixels[gY, gX]:= PLongword(@(p^[x * 4]))^
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	743	end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	744	p:= @(p^[Image^.pitch]);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	745	end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	746	end;
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	747	if SDL_MustLock(Image) then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	748	SDL_UnlockSurface(Image);
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	749
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	750	x:= Max(cpX, leftX);
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	751	w:= Min(cpX + Image^.w, LAND_WIDTH) - x;
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	752	y:= Max(cpY, topY);
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	753	h:= Min(cpY + Image^.h, LAND_HEIGHT) - y;
1807 795f97007833 Split land texture into small ones: unc0rr parents: 1806 diff changeset	754	UpdateLandTexture(x, w, y, h)
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	755	end;
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	756
5885 ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	757	function Despeckle(X, Y: LongInt): boolean;
4695 ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	758	var nx, ny, i, j, c, xx, yy: LongInt;
ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	759	pixelsweep: 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	760	begin
4695 ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	761	if (cReducedQuality and rqBlurryLand) = 0 then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	762	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	763	xx:= X;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	764	yy:= Y;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	765	end
4695 ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	766	else
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	767	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	768	xx:= X div 2;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	769	yy:= Y div 2;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	770	end;
4695 ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	771	pixelsweep:= ((Land[Y, X] and $FF00) = 0) and (LandPixels[yy, xx] <> 0);
5885 ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	772	if (((Land[Y, X] and lfDamaged) <> 0) and ((Land[Y, X] and lfIndestructible) = 0)) or pixelsweep then
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	773	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	774	c:= 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	775	for i:= -1 to 1 do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	776	for j:= -1 to 1 do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	777	if (i <> 0) or (j <> 0) then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	778	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	779	ny:= Y + i;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	780	nx:= X + j;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	781	if ((ny and LAND_HEIGHT_MASK) = 0) and ((nx and LAND_WIDTH_MASK) = 0) then
4695 ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	782	begin
ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	783	if pixelsweep then
ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	784	begin
ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	785	if ((cReducedQuality and rqBlurryLand) <> 0) then
ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	786	begin
ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	787	nx:= nx div 2;
ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	788	ny:= ny div 2
ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	789	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	790	if LandPixels[ny, nx] <> 0 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	791	inc(c);
4695 ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	792	end
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	793	else if Land[ny, nx] > 255 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	794	inc(c);
4695 ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	795	end
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	796	end;
5885 ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	797
ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	798	if c < 4 then // 0-3 neighbours
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	799	begin
6453 11c578d30bd3 Countless imporvements to the parser and countless help to the parser in sources. unc0rr parents: 6355 diff changeset	800	if ((Land[Y, X] and lfBasic) <> 0) and (not disableLandBack) then
4695 ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	801	LandPixels[yy, xx]:= LandBackPixel(X, Y)
4686 3682db294dae remove all screwing about with uLandGraphics - have not found a way to properly handle LandBackTex through despeckling or fill checks that does not result in ugly fire damage or wiped out landbacktex. Would rather some snowflakes lines than that. nemo parents: 4659 diff changeset	802	else
4695 ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	803	LandPixels[yy, xx]:= 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	804
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	805	if not pixelsweep then
6681 f46b1a1de2ce oops nemo parents: 6580 diff changeset	806	begin
f46b1a1de2ce oops nemo parents: 6580 diff changeset	807	Land[Y, X]:= 0;
f46b1a1de2ce oops nemo parents: 6580 diff changeset	808	exit(true)
f46b1a1de2ce oops nemo parents: 6580 diff changeset	809	end
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	810	end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	811	end;
5885 ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	812	Despeckle:= false
5267 e9ae019e9bb4 move smoothing into separate function, adjust call order nemo parents: 5266 diff changeset	813	end;
e9ae019e9bb4 move smoothing into separate function, adjust call order nemo parents: 5266 diff changeset	814
e9ae019e9bb4 move smoothing into separate function, adjust call order nemo parents: 5266 diff changeset	815	procedure Smooth(X, Y: LongInt);
e9ae019e9bb4 move smoothing into separate function, adjust call order nemo parents: 5266 diff changeset	816	begin
5261 2db030882bc9 More AA - try smoothing explosions a bit nemo parents: 5179 diff changeset	817	// a bit of AA for explosions
6011 519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code) unC0Rr parents: 5895 diff changeset	818	if (Land[Y, X] = 0) and (Y > LongInt(topY) + 1) and
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	819	(Y < LAND_HEIGHT-2) and (X > LongInt(leftX) + 1) and (X < LongInt(rightX) - 1) then
5261 2db030882bc9 More AA - try smoothing explosions a bit nemo parents: 5179 diff changeset	820	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	821	if ((((Land[y, x-1] and lfDamaged) <> 0) and (((Land[y+1,x] and lfDamaged) <> 0)) or ((Land[y-1,x] and lfDamaged) <> 0))
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	822	or (((Land[y, x+1] and lfDamaged) <> 0) and (((Land[y-1,x] and lfDamaged) <> 0) or ((Land[y+1,x] and lfDamaged) <> 0)))) then
5261 2db030882bc9 More AA - try smoothing explosions a bit nemo parents: 5179 diff changeset	823	begin
5274 941da059472b Avoid desyncing on blurry land nemo parents: 5267 diff changeset	824	if (cReducedQuality and rqBlurryLand) = 0 then
941da059472b Avoid desyncing on blurry land nemo parents: 5267 diff changeset	825	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	826	if ((LandPixels[y,x] and AMask) shr AShift) < 10 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	827	LandPixels[y,x]:= (cExplosionBorderColor and (not AMask)) or (128 shl AShift)
5274 941da059472b Avoid desyncing on blurry land nemo parents: 5267 diff changeset	828	else
941da059472b Avoid desyncing on blurry land nemo parents: 5267 diff changeset	829	LandPixels[y,x]:=
941da059472b Avoid desyncing on blurry land nemo parents: 5267 diff changeset	830	(((((LandPixels[y,x] and RMask shr RShift) div 2)+((cExplosionBorderColor and RMask) shr RShift) div 2) and $FF) shl RShift) or
941da059472b Avoid desyncing on blurry land nemo parents: 5267 diff changeset	831	(((((LandPixels[y,x] and GMask shr GShift) div 2)+((cExplosionBorderColor and GMask) shr GShift) div 2) and $FF) shl GShift) or
941da059472b Avoid desyncing on blurry land nemo parents: 5267 diff changeset	832	(((((LandPixels[y,x] and BMask shr BShift) div 2)+((cExplosionBorderColor and BMask) shr BShift) div 2) and $FF) shl BShift) or ($FF shl AShift)
941da059472b Avoid desyncing on blurry land nemo parents: 5267 diff changeset	833	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	834	if (Land[y, x-1] = lfObject) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	835	Land[y,x]:= lfObject
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	836	else if (Land[y, x+1] = lfObject) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	837	Land[y,x]:= lfObject
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	838	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	839	Land[y,x]:= lfBasic;
5261 2db030882bc9 More AA - try smoothing explosions a bit nemo parents: 5179 diff changeset	840	end
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	841	else if ((((Land[y, x-1] and lfDamaged) <> 0) and ((Land[y+1,x-1] and lfDamaged) <> 0) and ((Land[y+2,x] and lfDamaged) <> 0))
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	842	or (((Land[y, x-1] and lfDamaged) <> 0) and ((Land[y-1,x-1] and lfDamaged) <> 0) and ((Land[y-2,x] and lfDamaged) <> 0))
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	843	or (((Land[y, x+1] and lfDamaged) <> 0) and ((Land[y+1,x+1] and lfDamaged) <> 0) and ((Land[y+2,x] and lfDamaged) <> 0))
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	844	or (((Land[y, x+1] and lfDamaged) <> 0) and ((Land[y-1,x+1] and lfDamaged) <> 0) and ((Land[y-2,x] and lfDamaged) <> 0))
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	845	or (((Land[y+1, x] and lfDamaged) <> 0) and ((Land[y+1,x+1] and lfDamaged) <> 0) and ((Land[y,x+2] and lfDamaged) <> 0))
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	846	or (((Land[y-1, x] and lfDamaged) <> 0) and ((Land[y-1,x+1] and lfDamaged) <> 0) and ((Land[y,x+2] and lfDamaged) <> 0))
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	847	or (((Land[y+1, x] and lfDamaged) <> 0) and ((Land[y+1,x-1] and lfDamaged) <> 0) and ((Land[y,x-2] and lfDamaged) <> 0))
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	848	or (((Land[y-1, x] and lfDamaged) <> 0) and ((Land[y-1,x-1] and lfDamaged) <> 0) and ((Land[y,x-2] and lfDamaged) <> 0))) then
5261 2db030882bc9 More AA - try smoothing explosions a bit nemo parents: 5179 diff changeset	849	begin
5274 941da059472b Avoid desyncing on blurry land nemo parents: 5267 diff changeset	850	if (cReducedQuality and rqBlurryLand) = 0 then
941da059472b Avoid desyncing on blurry land nemo parents: 5267 diff changeset	851	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	852	if ((LandPixels[y,x] and AMask) shr AShift) < 10 then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	853	LandPixels[y,x]:= (cExplosionBorderColor and (not AMask)) or (64 shl AShift)
5274 941da059472b Avoid desyncing on blurry land nemo parents: 5267 diff changeset	854	else
941da059472b Avoid desyncing on blurry land nemo parents: 5267 diff changeset	855	LandPixels[y,x]:=
941da059472b Avoid desyncing on blurry land nemo parents: 5267 diff changeset	856	(((((LandPixels[y,x] and RMask shr RShift) * 3 div 4)+((cExplosionBorderColor and RMask) shr RShift) div 4) and $FF) shl RShift) or
941da059472b Avoid desyncing on blurry land nemo parents: 5267 diff changeset	857	(((((LandPixels[y,x] and GMask shr GShift) * 3 div 4)+((cExplosionBorderColor and GMask) shr GShift) div 4) and $FF) shl GShift) or
941da059472b Avoid desyncing on blurry land nemo parents: 5267 diff changeset	858	(((((LandPixels[y,x] and BMask shr BShift) * 3 div 4)+((cExplosionBorderColor and BMask) shr BShift) div 4) and $FF) shl BShift) or ($FF shl AShift)
941da059472b Avoid desyncing on blurry land nemo parents: 5267 diff changeset	859	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	860	if (Land[y, x-1] = lfObject) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	861	Land[y, x]:= lfObject
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	862	else if (Land[y, x+1] = lfObject) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	863	Land[y, x]:= lfObject
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	864	else if (Land[y+1, x] = lfObject) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	865	Land[y, x]:= lfObject
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	866	else if (Land[y-1, x] = lfObject) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	867	Land[y, x]:= lfObject
5687 fac606654317 Die speckles, round N. Check that alpha is not basically empty while blending, try to match the damaged land type. nemo parents: 5480 diff changeset	868	else Land[y,x]:= lfBasic
5261 2db030882bc9 More AA - try smoothing explosions a bit nemo parents: 5179 diff changeset	869	end
5267 e9ae019e9bb4 move smoothing into separate function, adjust call order nemo parents: 5266 diff changeset	870	end
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	871	else if ((cReducedQuality and rqBlurryLand) = 0) and (LandPixels[Y, X] and AMask = 255)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	872	and ((Land[Y, X] and (lfDamaged or lfBasic) = lfBasic) or (Land[Y, X] and (lfDamaged or lfBasic) = lfBasic))
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	873	and (Y > LongInt(topY) + 1) and (Y < LAND_HEIGHT-2) and (X > LongInt(leftX) + 1) and (X < LongInt(rightX) - 1) then
6130 026fd01a5e2c Blend the outter side too nemo parents: 6097 diff changeset	874	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	875	if ((((Land[y, x-1] and lfDamaged) <> 0) and (((Land[y+1,x] and lfDamaged) <> 0)) or ((Land[y-1,x] and lfDamaged) <> 0))
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	876	or (((Land[y, x+1] and lfDamaged) <> 0) and (((Land[y-1,x] and lfDamaged) <> 0) or ((Land[y+1,x] and lfDamaged) <> 0)))) then
6130 026fd01a5e2c Blend the outter side too nemo parents: 6097 diff changeset	877	begin
026fd01a5e2c Blend the outter side too nemo parents: 6097 diff changeset	878	LandPixels[y,x]:=
026fd01a5e2c Blend the outter side too nemo parents: 6097 diff changeset	879	(((((LandPixels[y,x] and RMask shr RShift) div 2)+((cExplosionBorderColor and RMask) shr RShift) div 2) and $FF) shl RShift) or
026fd01a5e2c Blend the outter side too nemo parents: 6097 diff changeset	880	(((((LandPixels[y,x] and GMask shr GShift) div 2)+((cExplosionBorderColor and GMask) shr GShift) div 2) and $FF) shl GShift) or
026fd01a5e2c Blend the outter side too nemo parents: 6097 diff changeset	881	(((((LandPixels[y,x] and BMask shr BShift) div 2)+((cExplosionBorderColor and BMask) shr BShift) div 2) and $FF) shl BShift) or ($FF shl AShift)
026fd01a5e2c Blend the outter side too nemo parents: 6097 diff changeset	882	end
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	883	else if ((((Land[y, x-1] and lfDamaged) <> 0) and ((Land[y+1,x-1] and lfDamaged) <> 0) and ((Land[y+2,x] and lfDamaged) <> 0))
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	884	or (((Land[y, x-1] and lfDamaged) <> 0) and ((Land[y-1,x-1] and lfDamaged) <> 0) and ((Land[y-2,x] and lfDamaged) <> 0))
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	885	or (((Land[y, x+1] and lfDamaged) <> 0) and ((Land[y+1,x+1] and lfDamaged) <> 0) and ((Land[y+2,x] and lfDamaged) <> 0))
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	886	or (((Land[y, x+1] and lfDamaged) <> 0) and ((Land[y-1,x+1] and lfDamaged) <> 0) and ((Land[y-2,x] and lfDamaged) <> 0))
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	887	or (((Land[y+1, x] and lfDamaged) <> 0) and ((Land[y+1,x+1] and lfDamaged) <> 0) and ((Land[y,x+2] and lfDamaged) <> 0))
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	888	or (((Land[y-1, x] and lfDamaged) <> 0) and ((Land[y-1,x+1] and lfDamaged) <> 0) and ((Land[y,x+2] and lfDamaged) <> 0))
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	889	or (((Land[y+1, x] and lfDamaged) <> 0) and ((Land[y+1,x-1] and lfDamaged) <> 0) and ((Land[y,x-2] and lfDamaged) <> 0))
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	890	or (((Land[y-1, x] and lfDamaged) <> 0) and ((Land[y-1,x-1] and lfDamaged) <> 0) and ((Land[y,x-2] and lfDamaged) <> 0))) then
6130 026fd01a5e2c Blend the outter side too nemo parents: 6097 diff changeset	891	begin
026fd01a5e2c Blend the outter side too nemo parents: 6097 diff changeset	892	LandPixels[y,x]:=
026fd01a5e2c Blend the outter side too nemo parents: 6097 diff changeset	893	(((((LandPixels[y,x] and RMask shr RShift) * 3 div 4)+((cExplosionBorderColor and RMask) shr RShift) div 4) and $FF) shl RShift) or
026fd01a5e2c Blend the outter side too nemo parents: 6097 diff changeset	894	(((((LandPixels[y,x] and GMask shr GShift) * 3 div 4)+((cExplosionBorderColor and GMask) shr GShift) div 4) and $FF) shl GShift) or
026fd01a5e2c Blend the outter side too nemo parents: 6097 diff changeset	895	(((((LandPixels[y,x] and BMask shr BShift) * 3 div 4)+((cExplosionBorderColor and BMask) shr BShift) div 4) and $FF) shl BShift) or ($FF shl AShift)
026fd01a5e2c Blend the outter side too nemo parents: 6097 diff changeset	896	end
026fd01a5e2c Blend the outter side too nemo parents: 6097 diff changeset	897	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	898	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	899
1792 c30c6944bd49 engine part of nemo's patch unc0rr parents: 1761 diff changeset	900	function SweepDirty: boolean;
5885 ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	901	var x, y, xx, yy, ty, tx: LongInt;
ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	902	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	903	begin
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2666 diff changeset	904	bRes:= false;
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	905	reCheck:= true;
1792 c30c6944bd49 engine part of nemo's patch unc0rr parents: 1761 diff changeset	906
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	907	while recheck do
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	908	begin
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	909	recheck:= false;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	910	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	911	begin
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	912	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	913	begin
5895 212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	914	if LandDirty[y, x] = 1 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	915	begin
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	916	updateBlock:= false;
5885 ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	917	resweep:= true;
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	918	ty:= y * 32;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	919	tx:= x * 32;
5885 ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	920	while(resweep) do
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	921	begin
5885 ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	922	resweep:= false;
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	923	for yy:= ty to ty + 31 do
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	924	for xx:= tx to tx + 31 do
5885 ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	925	if Despeckle(xx, yy) then
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	926	begin
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	927	bRes:= true;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	928	updateBlock:= true;
5885 ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	929	resweep:= true;
ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	930	if (yy = ty) and (y > 0) then
ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	931	begin
ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	932	LandDirty[y-1, x]:= 1;
ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	933	recheck:= true;
ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	934	end
ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	935	else if (yy = ty+31) and (y < LAND_HEIGHT div 32 - 1) then
ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	936	begin
ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	937	LandDirty[y+1, x]:= 1;
ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	938	recheck:= true;
ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	939	end;
ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	940	if (xx = tx) and (x > 0) then
ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	941	begin
ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	942	LandDirty[y, x-1]:= 1;
ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	943	recheck:= true;
ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	944	end
ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	945	else if (xx = tx+31) and (x < LAND_WIDTH div 32 - 1) then
ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	946	begin
ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	947	LandDirty[y, x+1]:= 1;
ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	948	recheck:= true;
ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	949	end
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	950	end;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	951	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	952	if updateBlock then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	953	UpdateLandTexture(tx, 32, ty, 32);
5895 212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	954	LandDirty[y, x]:= 2;
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	955	end;
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	956	end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	957	end;
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	958	end;
1792 c30c6944bd49 engine part of nemo's patch unc0rr parents: 1761 diff changeset	959
5895 212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	960	for y:= 0 to LAND_HEIGHT div 32 - 1 do
212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	961	for x:= 0 to LAND_WIDTH div 32 - 1 do
212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	962	if LandDirty[y, x] <> 0 then
212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	963	begin
212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	964	LandDirty[y, x]:= 0;
212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	965	ty:= y * 32;
212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	966	tx:= x * 32;
212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	967	for yy:= ty to ty + 31 do
212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	968	for xx:= tx to tx + 31 do
212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	969	Smooth(xx,yy)
212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	970	end;
212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	971
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2666 diff changeset	972	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	973	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	974
5885 ae257409bcff Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway. nemo parents: 5832 diff changeset	975
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	976	// 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
6096 a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	977	function CheckLandValue(X, Y: LongInt; LandFlag: Word): boolean; inline;
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	978	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	979	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	980	end;
4367 f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	981
6096 a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	982	function LandBackPixel(x, y: LongInt): LongWord; inline;
4367 f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	983	var p: PLongWordArray;
f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	984	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	985	if LandBackSurface = nil then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	986	LandBackPixel:= 0
4367 f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	987	else
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	988	begin
4367 f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	989	p:= LandBackSurface^.pixels;
f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	990	LandBackPixel:= p^[LandBackSurface^.w * (y mod LandBackSurface^.h) + (x mod LandBackSurface^.w)];// or $FF000000;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	991	end
4367 f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	992	end;
f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	993
f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	994
6490 531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	995	procedure DrawLine(X1, Y1, X2, Y2: LongInt; Color: Longword);
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	996	var
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	997	eX, eY, dX, dY: LongInt;
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	998	i, sX, sY, x, y, d: LongInt;
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	999	begin
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1000	eX:= 0;
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1001	eY:= 0;
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1002	dX:= X2 - X1;
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1003	dY:= Y2 - Y1;
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1004
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1005	if (dX > 0) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1006	sX:= 1
6490 531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1007	else
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1008	if (dX < 0) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1009	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1010	sX:= -1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1011	dX:= -dX
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1012	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1013	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1014	sX:= dX;
6490 531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1015
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1016	if (dY > 0) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1017	sY:= 1
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1018	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1019	if (dY < 0) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1020	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1021	sY:= -1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1022	dY:= -dY
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1023	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1024	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1025	sY:= dY;
6490 531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1026
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1027	if (dX > dY) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1028	d:= dX
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1029	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1030	d:= dY;
6490 531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1031
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1032	x:= X1;
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1033	y:= Y1;
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1034
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1035	for i:= 0 to d do
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1036	begin
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1037	inc(eX, dX);
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1038	inc(eY, dY);
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1039	if (eX > d) then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1040	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1041	dec(eX, d);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1042	inc(x, sX);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1043	end;
6490 531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1044	if (eY > d) then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1045	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1046	dec(eY, d);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1047	inc(y, sY);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1048	end;
6490 531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1049
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1050	if ((x and LAND_WIDTH_MASK) = 0) and ((y and LAND_HEIGHT_MASK) = 0) then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1051	Land[y, x]:= Color;
6490 531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1052	end
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1053	end;
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1054
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	1055	end.

author	koda
	Fri, 17 Feb 2012 18:23:36 +0100
changeset 6700	e04da46ee43c
parent 6681	f46b1a1de2ce
child 6982	8d41d22a291d
permissions	-rw-r--r--