hedgewars: hedgewars/uLandGraphics.pas@76e3a3fc17cd (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
7035 823caba67738 Reflects change in previous revision to uTypes nemo parents: 6990 diff changeset	25	type TRangeArray = array[0..31] of record
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	26	Left, Right: LongInt;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	27	end;
7035 823caba67738 Reflects change in previous revision to uTypes nemo parents: 6990 diff changeset	28	PRangeArray = ^TRangeArray;
184 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);
7270 93e92e82d5c8 Step 1. Add current hedgehog as top bit of bottom byte. nemo parents: 7268 diff changeset	39	procedure ChangeRoundInLand(X, Y, Radius: LongInt; doSet, isCurrent: 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);
7147 11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	42	procedure DrawThickLine(X1, Y1, X2, Y2, radius: LongInt; color: Longword);
7268 3a61c53346a8 - Fix cake bug introduced in r2ccfc93c6b5e unc0rr parents: 7170 diff changeset	43	procedure DumpLandToLog(x, y, r: LongInt);
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	44
4886 e3e5362a308e fixed unlimeted fuel bug for rcplane Henek parents: 4791 diff changeset	45	function TryPlaceOnLand(cpX, cpY: LongInt; Obj: TSprite; Frame: LongInt; doPlace: boolean; indestructible: boolean): boolean;
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	46
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	47	implementation
4403 0dfe26f48ec1 uDebug unc0rr parents: 4377 diff changeset	48	uses SDLh, uLandTexture, uVariables, uUtils, uDebug;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	49
4791 458d9854c679 Snow blends into land, trys to fill the gaps Palewolf parents: 4700 diff changeset	50	function addBgColor(OldColor, NewColor: LongWord): LongWord;
458d9854c679 Snow blends into land, trys to fill the gaps Palewolf parents: 4700 diff changeset	51	// Factor ranges from 0 to 100% NewColor
458d9854c679 Snow blends into land, trys to fill the gaps Palewolf parents: 4700 diff changeset	52	var
6011 519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code) unC0Rr parents: 5895 diff changeset	53	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	54	begin
6011 519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code) unC0Rr parents: 5895 diff changeset	55	oAlpha := (OldColor shr AShift);
519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code) unC0Rr parents: 5895 diff changeset	56	nAlpha := (NewColor shr AShift);
5692 753ae5d0776c implement proper blending nemo parents: 5687 diff changeset	57	// shortcircuit
753ae5d0776c implement proper blending nemo parents: 5687 diff changeset	58	if (oAlpha = 0) or (nAlpha = $FF) then
753ae5d0776c implement proper blending nemo parents: 5687 diff changeset	59	begin
753ae5d0776c implement proper blending nemo parents: 5687 diff changeset	60	addBgColor:= NewColor;
753ae5d0776c implement proper blending nemo parents: 5687 diff changeset	61	exit
7492 3188794b9d87 Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop nemo parents: 7270 diff changeset	62	end;
4791 458d9854c679 Snow blends into land, trys to fill the gaps Palewolf parents: 4700 diff changeset	63	// Get colors
6011 519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code) unC0Rr parents: 5895 diff changeset	64	oRed := (OldColor shr RShift);
519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code) unC0Rr parents: 5895 diff changeset	65	oGreen := (OldColor shr GShift);
519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code) unC0Rr parents: 5895 diff changeset	66	oBlue := (OldColor shr BShift);
4791 458d9854c679 Snow blends into land, trys to fill the gaps Palewolf parents: 4700 diff changeset	67
6011 519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code) unC0Rr parents: 5895 diff changeset	68	nRed := (NewColor shr RShift);
519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code) unC0Rr parents: 5895 diff changeset	69	nGreen := (NewColor shr GShift);
519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code) unC0Rr parents: 5895 diff changeset	70	nBlue := (NewColor shr BShift);
4791 458d9854c679 Snow blends into land, trys to fill the gaps Palewolf parents: 4700 diff changeset	71
458d9854c679 Snow blends into land, trys to fill the gaps Palewolf parents: 4700 diff changeset	72	// Mix colors
6011 519f8a58c021 Fix a bunch of warnings (also improves speed a bit in 32 bit code) unC0Rr parents: 5895 diff changeset	73	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	74	nGreen := min(255,((nGreennAlpha) div 255) + ((oGreenoAlpha*byte(255-nAlpha)) div 65025));
7492 3188794b9d87 Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop nemo parents: 7270 diff changeset	75	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	76	nAlpha := min(255, oAlpha + nAlpha);
458d9854c679 Snow blends into land, trys to fill the gaps Palewolf parents: 4700 diff changeset	77
5041 3dc6ad20cbfe Fix endianness nemo parents: 4976 diff changeset	78	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	79	end;
458d9854c679 Snow blends into land, trys to fill the gaps Palewolf parents: 4700 diff changeset	80
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	81	procedure FillCircleLines(x, y, dx, dy: LongInt; Value: Longword);
731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	82	var i: LongInt;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	83	begin
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	84	if ((y + dy) and LAND_HEIGHT_MASK) = 0 then
7509 76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	85	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	86	if (Land[y + dy, i] and lfIndestructible) = 0 then
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	87	Land[y + dy, i]:= Value;
2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	88	if ((y - dy) and LAND_HEIGHT_MASK) = 0 then
7509 76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	89	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	90	if (Land[y - dy, i] and lfIndestructible) = 0 then
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	91	Land[y - dy, i]:= Value;
2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	92	if ((y + dx) and LAND_HEIGHT_MASK) = 0 then
7509 76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	93	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	94	if (Land[y + dx, i] and lfIndestructible) = 0 then
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	95	Land[y + dx, i]:= Value;
2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	96	if ((y - dx) and LAND_HEIGHT_MASK) = 0 then
7509 76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	97	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	98	if (Land[y - dx, i] and lfIndestructible) = 0 then
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	99	Land[y - dx, i]:= Value;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	100	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	101
7270 93e92e82d5c8 Step 1. Add current hedgehog as top bit of bottom byte. nemo parents: 7268 diff changeset	102	procedure ChangeCircleLines(x, y, dx, dy: LongInt; doSet, isCurrent: boolean);
504 13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	103	var i: LongInt;
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	104	begin
511 2b5b9e00419d - Further work on new collisions implementation unc0rr parents: 505 diff changeset	105	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	106	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	107	if ((y + dy) and LAND_HEIGHT_MASK) = 0 then
7509 76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	108	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
7492 3188794b9d87 Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop nemo parents: 7270 diff changeset	109	if isCurrent then
7270 93e92e82d5c8 Step 1. Add current hedgehog as top bit of bottom byte. nemo parents: 7268 diff changeset	110	Land[y + dy, i]:= Land[y + dy, i] and $FF7F
93e92e82d5c8 Step 1. Add current hedgehog as top bit of bottom byte. nemo parents: 7268 diff changeset	111	else if Land[y + dy, i] and $007F > 0 then
93e92e82d5c8 Step 1. Add current hedgehog as top bit of bottom byte. nemo parents: 7268 diff changeset	112	Land[y + dy, i]:= (Land[y + dy, i] and $FF80) or ((Land[y + dy, i] and $7F) - 1);
6580 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 - dy) and LAND_HEIGHT_MASK) = 0 then
7509 76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	114	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
7492 3188794b9d87 Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop nemo parents: 7270 diff changeset	115	if isCurrent then
7270 93e92e82d5c8 Step 1. Add current hedgehog as top bit of bottom byte. nemo parents: 7268 diff changeset	116	Land[y - dy, i]:= Land[y - dy, i] and $FF7F
93e92e82d5c8 Step 1. Add current hedgehog as top bit of bottom byte. nemo parents: 7268 diff changeset	117	else if Land[y - dy, i] and $007F > 0 then
93e92e82d5c8 Step 1. Add current hedgehog as top bit of bottom byte. nemo parents: 7268 diff changeset	118	Land[y - dy, i]:= (Land[y - dy, i] and $FF80) or ((Land[y - dy, i] and $7F) - 1);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	119	if ((y + dx) and LAND_HEIGHT_MASK) = 0 then
7509 76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	120	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
7492 3188794b9d87 Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop nemo parents: 7270 diff changeset	121	if isCurrent then
7270 93e92e82d5c8 Step 1. Add current hedgehog as top bit of bottom byte. nemo parents: 7268 diff changeset	122	Land[y + dx, i]:= Land[y + dx, i] and $FF7F
93e92e82d5c8 Step 1. Add current hedgehog as top bit of bottom byte. nemo parents: 7268 diff changeset	123	else if Land[y + dx, i] and $007F > 0 then
93e92e82d5c8 Step 1. Add current hedgehog as top bit of bottom byte. nemo parents: 7268 diff changeset	124	Land[y + dx, i]:= (Land[y + dx, i] and $FF80) or ((Land[y + dx, i] and $7F) - 1);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	125	if ((y - dx) and LAND_HEIGHT_MASK) = 0 then
7509 76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	126	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
7492 3188794b9d87 Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop nemo parents: 7270 diff changeset	127	if isCurrent then
7270 93e92e82d5c8 Step 1. Add current hedgehog as top bit of bottom byte. nemo parents: 7268 diff changeset	128	Land[y - dx, i]:= Land[y - dx, i] and $FF7F
93e92e82d5c8 Step 1. Add current hedgehog as top bit of bottom byte. nemo parents: 7268 diff changeset	129	else if Land[y - dx, i] and $007F > 0 then
93e92e82d5c8 Step 1. Add current hedgehog as top bit of bottom byte. nemo parents: 7268 diff changeset	130	Land[y - dx, i]:= (Land[y - dx, i] and $FF80) or ((Land[y - dx, i] and $7F) - 1)
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	131	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	132	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	133	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	134	if ((y + dy) and LAND_HEIGHT_MASK) = 0 then
7509 76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	135	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
7492 3188794b9d87 Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop nemo parents: 7270 diff changeset	136	if isCurrent then
7270 93e92e82d5c8 Step 1. Add current hedgehog as top bit of bottom byte. nemo parents: 7268 diff changeset	137	Land[y + dy, i]:= Land[y + dy, i] or $80
93e92e82d5c8 Step 1. Add current hedgehog as top bit of bottom byte. nemo parents: 7268 diff changeset	138	else if Land[y + dy, i] and $007F < 127 then
93e92e82d5c8 Step 1. Add current hedgehog as top bit of bottom byte. nemo parents: 7268 diff changeset	139	Land[y + dy, i]:= (Land[y + dy, i] and $FF80) or ((Land[y + dy, i] and $7F) + 1);
7492 3188794b9d87 Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop nemo parents: 7270 diff changeset	140	if ((y - dy) and LAND_HEIGHT_MASK) = 0 then
7509 76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	141	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
7492 3188794b9d87 Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop nemo parents: 7270 diff changeset	142	if isCurrent then
3188794b9d87 Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop nemo parents: 7270 diff changeset	143	Land[y - dy, i]:= Land[y - dy, i] or $80
3188794b9d87 Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop nemo parents: 7270 diff changeset	144	else if Land[y - dy, i] and $007F < 127 then
7270 93e92e82d5c8 Step 1. Add current hedgehog as top bit of bottom byte. nemo parents: 7268 diff changeset	145	Land[y - dy, i]:= (Land[y - dy, i] and $FF80) or ((Land[y - dy, i] and $7F) + 1);
7492 3188794b9d87 Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop nemo parents: 7270 diff changeset	146	if ((y + dx) and LAND_HEIGHT_MASK) = 0 then
7509 76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	147	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
7492 3188794b9d87 Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop nemo parents: 7270 diff changeset	148	if isCurrent then
3188794b9d87 Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop nemo parents: 7270 diff changeset	149	Land[y + dx, i]:= Land[y + dx, i] or $80
3188794b9d87 Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop nemo parents: 7270 diff changeset	150	else if Land[y + dx, i] and $007F < 127 then
7270 93e92e82d5c8 Step 1. Add current hedgehog as top bit of bottom byte. nemo parents: 7268 diff changeset	151	Land[y + dx, i]:= (Land[y + dx, i] and $FF80) or ((Land[y + dx, i] and $7F) + 1);
7492 3188794b9d87 Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop nemo parents: 7270 diff changeset	152	if ((y - dx) and LAND_HEIGHT_MASK) = 0 then
7509 76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	153	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
7492 3188794b9d87 Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop nemo parents: 7270 diff changeset	154	if isCurrent then
3188794b9d87 Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop nemo parents: 7270 diff changeset	155	Land[y - dx, i]:= Land[y - dx, i] or $80
3188794b9d87 Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop nemo parents: 7270 diff changeset	156	else if Land[y - dx, i] and $007F < 127 then
7270 93e92e82d5c8 Step 1. Add current hedgehog as top bit of bottom byte. nemo parents: 7268 diff changeset	157	Land[y - dx, i]:= (Land[y - dx, i] and $FF80) or ((Land[y - dx, i] and $7F) + 1)
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	158	end
504 13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	159	end;
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	160
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	161	procedure FillRoundInLand(X, Y, Radius: LongInt; Value: Longword);
731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	162	var dx, dy, d: LongInt;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	163	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	164	dx:= 0;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	165	dy:= Radius;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	166	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	167	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	168	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	169	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	170	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	171	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	172	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	173	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	174	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	175	dec(dy)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	176	end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	177	inc(dx)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	178	end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	179	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	180	FillCircleLines(x, y, dx, dy, Value);
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	181	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	182
7270 93e92e82d5c8 Step 1. Add current hedgehog as top bit of bottom byte. nemo parents: 7268 diff changeset	183	procedure ChangeRoundInLand(X, Y, Radius: LongInt; doSet, isCurrent: boolean);
504 13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	184	var dx, dy, d: LongInt;
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	185	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	186	dx:= 0;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	187	dy:= Radius;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	188	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	189	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	190	begin
7270 93e92e82d5c8 Step 1. Add current hedgehog as top bit of bottom byte. nemo parents: 7268 diff changeset	191	ChangeCircleLines(x, y, dx, dy, doSet, isCurrent);
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	192	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	193	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	194	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	195	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	196	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	197	dec(dy)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	198	end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	199	inc(dx)
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	200	end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	201	if (dx = dy) then
7270 93e92e82d5c8 Step 1. Add current hedgehog as top bit of bottom byte. nemo parents: 7268 diff changeset	202	ChangeCircleLines(x, y, dx, dy, doSet, isCurrent)
504 13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	203	end;
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	204
2603 abed6070a669 revert previous commit to remove a wip patch koda parents: 2602 diff changeset	205	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	206	var i, t: LongInt;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	207	begin
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	208	t:= y + dy;
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
7509 76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	210	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	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 - dy;
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
7509 76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	219	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	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
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	226	t:= y + dx;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	227	if (t and LAND_HEIGHT_MASK) = 0 then
7509 76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	228	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	229	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	230	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	231	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	232	else
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	233	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	234
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	235	t:= y - dx;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	236	if (t and LAND_HEIGHT_MASK) = 0 then
7509 76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	237	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	238	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	239	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	240	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	241	else
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	242	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	243
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	244	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	245
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	246	function FillLandCircleLinesBG(x, y, dx, dy: LongInt): Longword;
5480 37bafa5a7016 kill off some speckles, crank up land gun output nemo parents: 5386 diff changeset	247	var i, t, by, bx: LongInt;
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	248	cnt: Longword;
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	249	begin
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	250	cnt:= 0;
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	251	t:= y + dy;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	252	if (t and LAND_HEIGHT_MASK) = 0 then
7509 76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	253	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	254	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	255	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	256	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	257	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	258	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	259	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	260	else
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 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	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	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	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	inc(cnt);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	267	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	268	end
7492 3188794b9d87 Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop nemo parents: 7270 diff changeset	269	else if ((Land[t, i] and lfObject) <> 0) or (((LandPixels[by,bx] and AMask) shr AShift) < 255) then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	270	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	271	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	272
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	273	t:= y - dy;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	274	if (t and LAND_HEIGHT_MASK) = 0 then
7509 76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	275	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	276	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	277	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	278	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	279	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	280	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	281	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	282	else
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 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	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	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	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	inc(cnt);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	289	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	290	end
7492 3188794b9d87 Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop nemo parents: 7270 diff changeset	291	else if ((Land[t, i] and lfObject) <> 0) or (((LandPixels[by,bx] and AMask) shr AShift) < 255) then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	292	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	293	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	294
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	295	t:= y + dx;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	296	if (t and LAND_HEIGHT_MASK) = 0 then
7509 76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	297	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	298	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	299	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	300	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	301	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	302	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	303	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	304	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	305	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	306	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	307	end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	308	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	309	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	310	inc(cnt);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	311	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	312	end
7492 3188794b9d87 Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop nemo parents: 7270 diff changeset	313	else if ((Land[t, i] and lfObject) <> 0) or (((LandPixels[by,bx] and AMask) shr AShift) < 255) then
6580 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]:= 0
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	315	end;
4695 ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	316	t:= y - dx;
ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	317	if (t and LAND_HEIGHT_MASK) = 0 then
7509 76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	318	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	319	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	320	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	321	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	322	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	323	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	324	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	325	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	326	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	327	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	328	end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	329	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	330	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	331	inc(cnt);
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	332	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	333	end
7492 3188794b9d87 Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop nemo parents: 7270 diff changeset	334	else if ((Land[t, i] and lfObject) <> 0) or (((LandPixels[by,bx] and AMask) shr AShift) < 255) then
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	335	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	336	end;
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	337	FillLandCircleLinesBG:= cnt;
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	338	end;
0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	339
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	340	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	341	var i, t: LongInt;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	342	begin
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	343	t:= y + dy;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	344	if (t and LAND_HEIGHT_MASK) = 0 then
7509 76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	345	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	346	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	347	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	348	if (cReducedQuality and rqBlurryLand) = 0 then
6982 8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	349	LandPixels[t, i]:= ExplosionBorderColor
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	350	else
6982 8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	351	LandPixels[t div 2, i div 2]:= ExplosionBorderColor;
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	352
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	353	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	354	//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	355	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	356	end;
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	357
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	358	t:= y - dy;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	359	if (t and LAND_HEIGHT_MASK) = 0 then
7509 76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	360	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	361	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	362	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	363	if (cReducedQuality and rqBlurryLand) = 0 then
6982 8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	364	LandPixels[t, i]:= ExplosionBorderColor
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	365	else
6982 8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	366	LandPixels[t div 2, i div 2]:= ExplosionBorderColor;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	367	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	368	//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	369	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	370	end;
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	371
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	372	t:= y + dx;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	373	if (t and LAND_HEIGHT_MASK) = 0 then
7509 76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	374	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	375	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	376	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	377	if (cReducedQuality and rqBlurryLand) = 0 then
6982 8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	378	LandPixels[t, i]:= ExplosionBorderColor
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	379	else
6982 8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	380	LandPixels[t div 2, i div 2]:= ExplosionBorderColor;
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	381
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	382	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	383	//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	384	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	385	end;
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	386
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	387	t:= y - dx;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	388	if (t and LAND_HEIGHT_MASK) = 0 then
7509 76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	389	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	390	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	391	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	392	if (cReducedQuality and rqBlurryLand) = 0 then
6982 8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	393	LandPixels[t, i]:= ExplosionBorderColor
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	394	else
6982 8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	395	LandPixels[t div 2, i div 2]:= ExplosionBorderColor;
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	396
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	397	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	398	//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	399	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	400	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	401	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	402
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	403	function DrawExplosion(X, Y, Radius: LongInt): Longword;
2603 abed6070a669 revert previous commit to remove a wip patch koda parents: 2602 diff changeset	404	var dx, dy, ty, tx, d: LongInt;
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	405	cnt: Longword;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	406	begin
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	407
0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	408	// draw background land texture
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	409	begin
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	410	cnt:= 0;
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	411	dx:= 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	412	dy:= Radius;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	413	d:= 3 - 2 * Radius;
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	414
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	415	while (dx < dy) do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	416	begin
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	417	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	418	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	419	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	420	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	421	begin
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	422	d:= d + 4 * (dx - dy) + 10;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	423	dec(dy)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	424	end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	425	inc(dx)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	426	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	427	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	428	inc(cnt, FillLandCircleLinesBG(x, y, dx, dy));
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	429	end;
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	430
0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	431	// draw a hole in land
2733 52a5a160566f Engine: smxx parents: 2716 diff changeset	432	if Radius > 20 then
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	433	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	434	dx:= 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	435	dy:= Radius - 15;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	436	d:= 3 - 2 * dy;
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	437
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	438	while (dx < dy) do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	439	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	440	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	441	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	442	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	443	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	444	begin
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	445	d:= d + 4 * (dx - dy) + 10;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	446	dec(dy)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	447	end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	448	inc(dx)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	449	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	450	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	451	FillLandCircleLines0(x, y, dx, dy);
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	452	end;
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	453
1849 2a989e5abda6 4 utilities by nemo unc0rr parents: 1809 diff changeset	454	// 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	455	FillRoundInLand(X, Y, Radius, 0);
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	456
0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	457	// draw explosion border
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	458	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	459	inc(Radius, 4);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	460	dx:= 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	461	dy:= Radius;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	462	d:= 3 - 2 * Radius;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	463	while (dx < dy) do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	464	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	465	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	466	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	467	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	468	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	469	begin
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	470	d:= d + 4 * (dx - dy) + 10;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	471	dec(dy)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	472	end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	473	inc(dx)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	474	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	475	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	476	FillLandCircleLinesEBC(x, y, dx, dy);
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	477	end;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 345 diff changeset	478
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	479	tx:= Max(X - Radius - 1, 0);
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	480	dx:= Min(X + Radius + 1, LAND_WIDTH) - tx;
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	481	ty:= Max(Y - Radius - 1, 0);
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	482	dy:= Min(Y + Radius + 1, LAND_HEIGHT) - ty;
7170 84ac6c6d2d8e Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws nemo parents: 7150 diff changeset	483	UpdateLandTexture(tx, dx, ty, dy, false);
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	484	DrawExplosion:= cnt
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	485	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	486
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	487	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	488	var tx, ty, by, bx, i: LongInt;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	489	begin
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	490	for i:= 0 to Pred(Count) do
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	491	begin
7509 76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	492	for ty:= Max(y - Radius, 0) to Min(y + Radius, LAND_HEIGHT) do
76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	493	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	494	begin
6096 a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	495	if (Land[ty, tx] and lfIndestructible) = 0 then
5480 37bafa5a7016 kill off some speckles, crank up land gun output nemo parents: 5386 diff changeset	496	begin
6096 a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	497	if (cReducedQuality and rqBlurryLand) = 0 then
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	498	begin
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	499	by:= ty; bx:= tx;
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	500	end
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	501	else
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	502	begin
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	503	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	504	end;
6355 734fed7aefd3 Introduce initialization expressions unc0rr parents: 6132 diff changeset	505	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	506	LandPixels[by, bx]:= LandBackPixel(tx, ty)
7492 3188794b9d87 Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop nemo parents: 7270 diff changeset	507	else if ((Land[ty, tx] and lfObject) <> 0) or (((LandPixels[by,bx] and AMask) shr AShift) < 255) then
6096 a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	508	LandPixels[by, bx]:= 0
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	509	end
5480 37bafa5a7016 kill off some speckles, crank up land gun output nemo parents: 5386 diff changeset	510	end;
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	511	inc(y, dY)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	512	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	513
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	514	inc(Radius, 4);
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 345 diff changeset	515	dec(y, Count * dY);
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	516
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	517	for i:= 0 to Pred(Count) do
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	518	begin
7509 76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	519	for ty:= Max(y - Radius, 0) to Min(y + Radius, LAND_HEIGHT) do
76e3a3fc17cd revert 3188794b9d87. does not do what I'd like. nemo parents: 7492 diff changeset	520	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	521	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	522	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	523	if (cReducedQuality and rqBlurryLand) = 0 then
6982 8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	524	LandPixels[ty, tx]:= ExplosionBorderColor
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	525	else
6982 8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	526	LandPixels[ty div 2, tx div 2]:= ExplosionBorderColor;
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	527
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	528	Land[ty, tx]:= Land[ty, tx] or lfDamaged;
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	529	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	530	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	531	inc(y, dY)
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	532	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	533
818 635e58295079 Fix drill bug unc0rr parents: 772 diff changeset	534
7170 84ac6c6d2d8e Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws nemo parents: 7150 diff changeset	535	UpdateLandTexture(0, LAND_WIDTH, 0, LAND_HEIGHT, false)
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	536	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	537
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	538	//
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	539	// - (dX, dY) - direction, vector of length = 0.5
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	540	//
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	541	procedure DrawTunnel(X, Y, dX, dY: hwFloat; ticks, HalfWidth: LongInt);
358 236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	542	var nx, ny, dX8, dY8: hwFloat;
5480 37bafa5a7016 kill off some speckles, crank up land gun output nemo parents: 5386 diff changeset	543	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	544	despeckle : Boolean;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	545	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	546	stY:= hwRound(Y);
1809 77923087a1ce Some optimization of land texture updating unc0rr parents: 1807 diff changeset	547	stX:= hwRound(X);
772 e8d530ca77be Don't update all land texture when drawing tunnel (saves video throughput) unc0rr parents: 769 diff changeset	548
5332 b29d60c7cac7 Use an ifdef instead, add despeckling of tunnels nemo parents: 5322 diff changeset	549	despeckle:= HalfWidth > 1;
b29d60c7cac7 Use an ifdef instead, add despeckling of tunnels nemo parents: 5322 diff changeset	550
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	551	nx:= X + dY * (HalfWidth + 8);
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	552	ny:= Y - dX * (HalfWidth + 8);
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	553
358 236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	554	dX8:= dX * 8;
236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	555	dY8:= dY * 8;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	556	for i:= 0 to 7 do
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	557	begin
358 236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	558	X:= nx - dX8;
236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	559	Y:= ny - dY8;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	560	for t:= -8 to ticks + 8 do
2666 2b8c8f16421e update SDLMain.m/.h to latest version koda parents: 2648 diff changeset	561	begin
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	562	X:= X + dX;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	563	Y:= Y + dY;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	564	tx:= hwRound(X);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	565	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	566	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	567	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	568	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	569	begin
7492 3188794b9d87 Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop nemo parents: 7270 diff changeset	570	if despeckle then
5887 7d69b76ce923 Don't set lfDamaged for small tunnels nemo parents: 5885 diff changeset	571	begin
7d69b76ce923 Don't set lfDamaged for small tunnels nemo parents: 5885 diff changeset	572	Land[ty, tx]:= Land[ty, tx] or lfDamaged;
7d69b76ce923 Don't set lfDamaged for small tunnels nemo parents: 5885 diff changeset	573	LandDirty[ty div 32, tx div 32]:= 1
7d69b76ce923 Don't set lfDamaged for small tunnels nemo parents: 5885 diff changeset	574	end;
5332 b29d60c7cac7 Use an ifdef instead, add despeckling of tunnels nemo parents: 5322 diff changeset	575	if (cReducedQuality and rqBlurryLand) = 0 then
6982 8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	576	LandPixels[ty, tx]:= ExplosionBorderColor
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	577	else
6982 8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	578	LandPixels[ty div 2, tx div 2]:= ExplosionBorderColor
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	579	end
2666 2b8c8f16421e update SDLMain.m/.h to latest version koda parents: 2648 diff changeset	580	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	581	nx:= nx - dY;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	582	ny:= ny + dX;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	583	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	584
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	585	for i:= -HalfWidth to HalfWidth do
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	586	begin
358 236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	587	X:= nx - dX8;
236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	588	Y:= ny - dY8;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	589	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	590	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	591	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	592	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	593	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	594	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	595	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	596	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	597	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	598	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	599	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	600	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	601	if (cReducedQuality and rqBlurryLand) = 0 then
6982 8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	602	LandPixels[ty, tx]:= ExplosionBorderColor
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	603	else
6982 8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	604	LandPixels[ty div 2, tx div 2]:= ExplosionBorderColor
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	605	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	606	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	607	X:= nx;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	608	Y:= ny;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	609	for t:= 0 to ticks do
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	610	begin
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	611	X:= X + dX;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	612	Y:= Y + dY;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 345 diff changeset	613	tx:= hwRound(X);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 345 diff changeset	614	ty:= hwRound(Y);
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	615	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	616	begin
5480 37bafa5a7016 kill off some speckles, crank up land gun output nemo parents: 5386 diff changeset	617	if (cReducedQuality and rqBlurryLand) = 0 then
37bafa5a7016 kill off some speckles, crank up land gun output nemo parents: 5386 diff changeset	618	begin
37bafa5a7016 kill off some speckles, crank up land gun output nemo parents: 5386 diff changeset	619	by:= ty; bx:= tx;
37bafa5a7016 kill off some speckles, crank up land gun output nemo parents: 5386 diff changeset	620	end
4690 490cf71b436a revert last change. ordinary fire is fine, but HHG screws up. nemo parents: 4688 diff changeset	621	else
5480 37bafa5a7016 kill off some speckles, crank up land gun output nemo parents: 5386 diff changeset	622	begin
37bafa5a7016 kill off some speckles, crank up land gun output nemo parents: 5386 diff changeset	623	by:= ty div 2; bx:= tx div 2;
37bafa5a7016 kill off some speckles, crank up land gun output nemo parents: 5386 diff changeset	624	end;
6355 734fed7aefd3 Introduce initialization expressions unc0rr parents: 6132 diff changeset	625	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	626	LandPixels[by, bx]:= LandBackPixel(tx, ty)
a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	627	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	628	LandPixels[by, bx]:= 0;
db10abae541f Couple more, add back misplaced clearing of Land nemo parents: 6096 diff changeset	629	Land[ty, tx]:= 0;
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	630	end
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	631	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	632	for t:= 0 to 7 do
2666 2b8c8f16421e update SDLMain.m/.h to latest version koda parents: 2648 diff changeset	633	begin
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	634	X:= X + dX;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	635	Y:= Y + dY;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	636	tx:= hwRound(X);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	637	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	638	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	639	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	640	begin
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	641	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	642	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	643	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	644	if (cReducedQuality and rqBlurryLand) = 0 then
6982 8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	645	LandPixels[ty, tx]:= ExplosionBorderColor
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	646	else
6982 8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	647	LandPixels[ty div 2, tx div 2]:= ExplosionBorderColor
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	end
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	649	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	650	nx:= nx - dY;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	651	ny:= ny + dX;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	652	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	653
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	654	for i:= 0 to 7 do
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	655	begin
358 236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	656	X:= nx - dX8;
236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	657	Y:= ny - dY8;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	658	for t:= -8 to ticks + 8 do
2666 2b8c8f16421e update SDLMain.m/.h to latest version koda parents: 2648 diff changeset	659	begin
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	660	X:= X + dX;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	661	Y:= Y + dY;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	662	tx:= hwRound(X);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	663	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	664	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	665	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	666	begin
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	667	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	668	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	669	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	670	if (cReducedQuality and rqBlurryLand) = 0 then
6982 8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	671	LandPixels[ty, tx]:= ExplosionBorderColor
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	672	else
6982 8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	673	LandPixels[ty div 2, tx div 2]:= ExplosionBorderColor
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	674	end
2666 2b8c8f16421e update SDLMain.m/.h to latest version koda parents: 2648 diff changeset	675	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	676	nx:= nx - dY;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	677	ny:= ny + dX;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	678	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	679
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	680	tx:= Max(stX - HalfWidth * 2 - 4 - abs(hwRound(dX * ticks)), 0);
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	681	ty:= Max(stY - HalfWidth * 2 - 4 - abs(hwRound(dY * ticks)), 0);
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	682	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	683	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	684
7170 84ac6c6d2d8e Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws nemo parents: 7150 diff changeset	685	UpdateLandTexture(tx, ddx, ty, ddy, false)
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	686	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	687
4886 e3e5362a308e fixed unlimeted fuel bug for rcplane Henek parents: 4791 diff changeset	688	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	689	var X, Y, bpp, h, w, row, col, gx, gy, numFramesFirstCol: LongInt;
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	690	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	691	Image: PSDL_Surface;
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	692	begin
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	693	TryPlaceOnLand:= false;
2235 79c9542c1058 multi-column support nemo parents: 2167 diff changeset	694	numFramesFirstCol:= SpritesData[Obj].imageHeight div SpritesData[Obj].Height;
79c9542c1058 multi-column support nemo parents: 2167 diff changeset	695
769 788efc1d649f - Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization unc0rr parents: 768 diff changeset	696	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	697	Image:= SpritesData[Obj].Surface;
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	698	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	699	h:= SpritesData[Obj].Height;
2235 79c9542c1058 multi-column support nemo parents: 2167 diff changeset	700	row:= Frame mod numFramesFirstCol;
79c9542c1058 multi-column support nemo parents: 2167 diff changeset	701	col:= Frame div numFramesFirstCol;
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	702
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	703	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	704	SDLTry(SDL_LockSurface(Image) >= 0, true);
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	705
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	706	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	707	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	708	// Check that sprite fits free space
2236 af8fc3311748 the -1 was a bad idea nemo parents: 2235 diff changeset	709	p:= @(PByteArray(Image^.pixels)^[ Image^.pitch * row * h + col * w * 4 ]);
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	710	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	711	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	712	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	713	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	714	if (PLongword(@(p^[x * 4]))^) <> 0 then
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	715	if ((cpY + y) <= Longint(topY)) or ((cpY + y) >= LAND_HEIGHT) or
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	716	((cpX + x) <= Longint(leftX)) or ((cpX + x) >= Longint(rightX)) or (Land[cpY + y, cpX + x] <> 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	717	begin
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	718	if SDL_MustLock(Image) then
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	719	SDL_UnlockSurface(Image);
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	720	exit;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	721	end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	722	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	723	end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	724	end;
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	725
520 e83dfb7ffead Teleportation tool unc0rr parents: 511 diff changeset	726	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	727	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	728	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	729	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	730	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	731	exit
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	732	end;
520 e83dfb7ffead Teleportation tool unc0rr parents: 511 diff changeset	733
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	734	// Checked, now place
2236 af8fc3311748 the -1 was a bad idea nemo parents: 2235 diff changeset	735	p:= @(PByteArray(Image^.pixels)^[ Image^.pitch * row * h + col * w * 4 ]);
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	736	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	737	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	738	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	739	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	740	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	741	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	742	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	743	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	744	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	745	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	746	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	747	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	748	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	749	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	750	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	751	end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	752	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	753	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	754	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	755	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	756	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	757	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	758	// 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	759	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	760	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	761	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	762	end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	763	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	764	end;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	765	end;
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	766	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	767	SDL_UnlockSurface(Image);
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	768
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	769	x:= Max(cpX, leftX);
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	770	w:= Min(cpX + Image^.w, LAND_WIDTH) - x;
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	771	y:= Max(cpY, topY);
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	772	h:= Min(cpY + Image^.h, LAND_HEIGHT) - y;
7170 84ac6c6d2d8e Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws nemo parents: 7150 diff changeset	773	UpdateLandTexture(x, w, y, h, true)
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	774	end;
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	775
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	776	function Despeckle(X, Y: LongInt): boolean;
4695 ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	777	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	778	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	779	begin
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	780	Despeckle:= true;
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	781
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	782	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	783	begin
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	784	xx:= X;
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	785	yy:= Y;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	786	end
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	787	else
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	788	begin
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	789	xx:= X div 2;
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	790	yy:= Y div 2;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	791	end;
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	792
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	793	pixelsweep:= ((Land[Y, X] and $FF00) = 0) and (LandPixels[yy, xx] <> 0);
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	794	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	795	begin
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	796	c:= 0;
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	797	for i:= -1 to 1 do
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	798	for j:= -1 to 1 do
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	799	if (i <> 0) or (j <> 0) then
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	800	begin
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	801	ny:= Y + i;
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	802	nx:= X + j;
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	803	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	804	begin
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	805	if pixelsweep then
4695 ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	806	begin
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	807	if ((cReducedQuality and rqBlurryLand) <> 0) then
4695 ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	808	begin
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	809	nx:= nx div 2;
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	810	ny:= ny div 2
4695 ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	811	end;
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	812	if LandPixels[ny, nx] <> 0 then
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	813	inc(c);
4695 ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	814	end
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	815	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	816	inc(c);
4695 ac2cb3b99d70 add a disabling for landback, set it if flakes are enabled nemo parents: 4690 diff changeset	817	end
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	818	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	819
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	820	if c < 4 then // 0-3 neighbours
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	821	begin
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	822	if ((Land[Y, X] and lfBasic) <> 0) and (not disableLandBack) then
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	823	LandPixels[yy, xx]:= LandBackPixel(X, Y)
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	824	else
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	825	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	826
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	827	if not pixelsweep then
6681 f46b1a1de2ce oops nemo parents: 6580 diff changeset	828	begin
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	829	Land[Y, X]:= 0;
40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	830	exit
6681 f46b1a1de2ce oops nemo parents: 6580 diff changeset	831	end
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	832	end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	833	end;
6990 40e5af28d026 change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity) koda parents: 6982 diff changeset	834	Despeckle:= false
5267 e9ae019e9bb4 move smoothing into separate function, adjust call order nemo parents: 5266 diff changeset	835	end;
e9ae019e9bb4 move smoothing into separate function, adjust call order nemo parents: 5266 diff changeset	836
e9ae019e9bb4 move smoothing into separate function, adjust call order nemo parents: 5266 diff changeset	837	procedure Smooth(X, Y: LongInt);
e9ae019e9bb4 move smoothing into separate function, adjust call order nemo parents: 5266 diff changeset	838	begin
5261 2db030882bc9 More AA - try smoothing explosions a bit nemo parents: 5179 diff changeset	839	// a bit of AA for explosions
7492 3188794b9d87 Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop nemo parents: 7270 diff changeset	840	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	841	(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	842	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	843	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	844	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	845	begin
5274 941da059472b Avoid desyncing on blurry land nemo parents: 5267 diff changeset	846	if (cReducedQuality and rqBlurryLand) = 0 then
941da059472b Avoid desyncing on blurry land nemo parents: 5267 diff changeset	847	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	848	if ((LandPixels[y,x] and AMask) shr AShift) < 10 then
6982 8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	849	LandPixels[y,x]:= (ExplosionBorderColor and (not AMask)) or (128 shl AShift)
5274 941da059472b Avoid desyncing on blurry land nemo parents: 5267 diff changeset	850	else
941da059472b Avoid desyncing on blurry land nemo parents: 5267 diff changeset	851	LandPixels[y,x]:=
6982 8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	852	(((((LandPixels[y,x] and RMask shr RShift) div 2)+((ExplosionBorderColor and RMask) shr RShift) div 2) and $FF) shl RShift) or
8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	853	(((((LandPixels[y,x] and GMask shr GShift) div 2)+((ExplosionBorderColor and GMask) shr GShift) div 2) and $FF) shl GShift) or
8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	854	(((((LandPixels[y,x] and BMask shr BShift) div 2)+((ExplosionBorderColor and BMask) shr BShift) div 2) and $FF) shl BShift) or ($FF shl AShift)
5274 941da059472b Avoid desyncing on blurry land nemo parents: 5267 diff changeset	855	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	856	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	857	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	858	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	859	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	860	else
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]:= lfBasic;
5261 2db030882bc9 More AA - try smoothing explosions a bit nemo parents: 5179 diff changeset	862	end
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	863	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	864	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	865	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	866	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	867	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	868	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	869	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	870	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	871	begin
5274 941da059472b Avoid desyncing on blurry land nemo parents: 5267 diff changeset	872	if (cReducedQuality and rqBlurryLand) = 0 then
941da059472b Avoid desyncing on blurry land nemo parents: 5267 diff changeset	873	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	874	if ((LandPixels[y,x] and AMask) shr AShift) < 10 then
6982 8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	875	LandPixels[y,x]:= (ExplosionBorderColor and (not AMask)) or (64 shl AShift)
5274 941da059472b Avoid desyncing on blurry land nemo parents: 5267 diff changeset	876	else
941da059472b Avoid desyncing on blurry land nemo parents: 5267 diff changeset	877	LandPixels[y,x]:=
6982 8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	878	(((((LandPixels[y,x] and RMask shr RShift) * 3 div 4)+((ExplosionBorderColor and RMask) shr RShift) div 4) and $FF) shl RShift) or
8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	879	(((((LandPixels[y,x] and GMask shr GShift) * 3 div 4)+((ExplosionBorderColor and GMask) shr GShift) div 4) and $FF) shl GShift) or
8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	880	(((((LandPixels[y,x] and BMask shr BShift) * 3 div 4)+((ExplosionBorderColor and BMask) shr BShift) div 4) and $FF) shl BShift) or ($FF shl AShift)
5274 941da059472b Avoid desyncing on blurry land nemo parents: 5267 diff changeset	881	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	882	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	883	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	884	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	885	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	886	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	887	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	888	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	889	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	890	else Land[y,x]:= lfBasic
5261 2db030882bc9 More AA - try smoothing explosions a bit nemo parents: 5179 diff changeset	891	end
5267 e9ae019e9bb4 move smoothing into separate function, adjust call order nemo parents: 5266 diff changeset	892	end
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	893	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	894	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	895	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	896	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	897	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	898	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	899	begin
026fd01a5e2c Blend the outter side too nemo parents: 6097 diff changeset	900	LandPixels[y,x]:=
6982 8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	901	(((((LandPixels[y,x] and RMask shr RShift) div 2)+((ExplosionBorderColor and RMask) shr RShift) div 2) and $FF) shl RShift) or
8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	902	(((((LandPixels[y,x] and GMask shr GShift) div 2)+((ExplosionBorderColor and GMask) shr GShift) div 2) and $FF) shl GShift) or
8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	903	(((((LandPixels[y,x] and BMask shr BShift) div 2)+((ExplosionBorderColor and BMask) shr BShift) div 2) and $FF) shl BShift) or ($FF shl AShift)
6130 026fd01a5e2c Blend the outter side too nemo parents: 6097 diff changeset	904	end
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	905	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	906	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	907	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	908	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	909	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	910	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	911	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	912	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	913	begin
026fd01a5e2c Blend the outter side too nemo parents: 6097 diff changeset	914	LandPixels[y,x]:=
6982 8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	915	(((((LandPixels[y,x] and RMask shr RShift) * 3 div 4)+((ExplosionBorderColor and RMask) shr RShift) div 4) and $FF) shl RShift) or
8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	916	(((((LandPixels[y,x] and GMask shr GShift) * 3 div 4)+((ExplosionBorderColor and GMask) shr GShift) div 4) and $FF) shl GShift) or
8d41d22a291d breaking news, we don't support typed consts anymore koda parents: 6700 diff changeset	917	(((((LandPixels[y,x] and BMask shr BShift) * 3 div 4)+((ExplosionBorderColor and BMask) shr BShift) div 4) and $FF) shl BShift) or ($FF shl AShift)
6130 026fd01a5e2c Blend the outter side too nemo parents: 6097 diff changeset	918	end
026fd01a5e2c Blend the outter side too nemo parents: 6097 diff changeset	919	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	920	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	921
1792 c30c6944bd49 engine part of nemo's patch unc0rr parents: 1761 diff changeset	922	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	923	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	924	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	925	begin
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2666 diff changeset	926	bRes:= false;
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	927	reCheck:= true;
1792 c30c6944bd49 engine part of nemo's patch unc0rr parents: 1761 diff changeset	928
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	929	while recheck do
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	930	begin
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	931	recheck:= false;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	932	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	933	begin
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	934	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	935	begin
5895 212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	936	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	937	begin
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	938	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	939	resweep:= true;
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	940	ty:= y * 32;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	941	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	942	while(resweep) do
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	943	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	944	resweep:= false;
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	945	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	946	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	947	if Despeckle(xx, yy) then
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	948	begin
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	949	bRes:= true;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	950	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	951	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	952	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	953	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	954	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	955	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	956	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	957	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	958	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	959	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	960	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	961	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	962	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	963	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	964	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	965	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	966	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	967	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	968	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	969	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	970	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	971	end
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	972	end;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	973	end;
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	974	if updateBlock then
7170 84ac6c6d2d8e Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws nemo parents: 7150 diff changeset	975	UpdateLandTexture(tx, 32, ty, 32, false);
5895 212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	976	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	977	end;
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	978	end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	979	end;
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	980	end;
1792 c30c6944bd49 engine part of nemo's patch unc0rr parents: 1761 diff changeset	981
5895 212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	982	for y:= 0 to LAND_HEIGHT div 32 - 1 do
212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	983	for x:= 0 to LAND_WIDTH div 32 - 1 do
212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	984	if LandDirty[y, x] <> 0 then
212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	985	begin
212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	986	LandDirty[y, x]:= 0;
212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	987	ty:= y * 32;
212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	988	tx:= x * 32;
212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	989	for yy:= ty to ty + 31 do
212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	990	for xx:= tx to tx + 31 do
212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	991	Smooth(xx,yy)
212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	992	end;
212d3b459658 smoothing should be after despeckling nemo parents: 5887 diff changeset	993
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2666 diff changeset	994	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	995	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	996
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	997
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	998	// 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	999	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	1000	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1001	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	1002	end;
4367 f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	1003
6096 a00dbbf49d6c Add landbacktex to a few maps, just to see how it looks. nemo parents: 6081 diff changeset	1004	function LandBackPixel(x, y: LongInt): LongWord; inline;
4367 f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	1005	var p: PLongWordArray;
f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	1006	begin
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1007	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	1008	LandBackPixel:= 0
4367 f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	1009	else
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1010	begin
4367 f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	1011	p:= LandBackSurface^.pixels;
f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	1012	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	1013	end
4367 f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	1014	end;
f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	1015
f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	1016
6490 531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1017	procedure DrawLine(X1, Y1, X2, Y2: LongInt; Color: Longword);
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1018	var
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1019	eX, eY, dX, dY: LongInt;
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1020	i, sX, sY, x, y, d: LongInt;
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1021	begin
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1022	eX:= 0;
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1023	eY:= 0;
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1024	dX:= X2 - X1;
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1025	dY:= Y2 - Y1;
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 > 0) then
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1028	sX:= 1
6490 531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1029	else
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1030	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	1031	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1032	sX:= -1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1033	dX:= -dX
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1034	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1035	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1036	sX:= dX;
6490 531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1037
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1038	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	1039	sY:= 1
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1040	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1041	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	1042	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1043	sY:= -1;
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1044	dY:= -dY
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1045	end
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1046	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1047	sY:= dY;
6490 531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1048
6580 6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1049	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	1050	d:= dX
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1051	else
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1052	d:= dY;
6490 531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1053
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1054	x:= X1;
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1055	y:= Y1;
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1056
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1057	for i:= 0 to d do
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1058	begin
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1059	inc(eX, dX);
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1060	inc(eY, dY);
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1061	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	1062	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1063	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	1064	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	1065	end;
6490 531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1066	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	1067	begin
6155187bf599 A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent. lovelacer parents: 6490 diff changeset	1068	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	1069	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	1070	end;
6490 531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1071
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1072	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	1073	Land[y, x]:= Color;
6490 531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1074	end
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1075	end;
531bf083e8db - Give uLand more modularity unc0rr parents: 6453 diff changeset	1076
7150 fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1077	procedure DrawDots(x, y, xx, yy: Longint; Color: Longword); inline;
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1078	begin
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1079	if (((x + xx) and LAND_WIDTH_MASK) = 0) and (((y + yy) and LAND_HEIGHT_MASK) = 0) then Land[y + yy, x + xx]:= Color;
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1080	if (((x + xx) and LAND_WIDTH_MASK) = 0) and (((y - yy) and LAND_HEIGHT_MASK) = 0) then Land[y - yy, x + xx]:= Color;
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1081	if (((x - xx) and LAND_WIDTH_MASK) = 0) and (((y + yy) and LAND_HEIGHT_MASK) = 0) then Land[y + yy, x - xx]:= Color;
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1082	if (((x - xx) and LAND_WIDTH_MASK) = 0) and (((y - yy) and LAND_HEIGHT_MASK) = 0) then Land[y - yy, x - xx]:= Color;
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1083	if (((x + yy) and LAND_WIDTH_MASK) = 0) and (((y + xx) and LAND_HEIGHT_MASK) = 0) then Land[y + xx, x + yy]:= Color;
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1084	if (((x + yy) and LAND_WIDTH_MASK) = 0) and (((y - xx) and LAND_HEIGHT_MASK) = 0) then Land[y - xx, x + yy]:= Color;
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1085	if (((x - yy) and LAND_WIDTH_MASK) = 0) and (((y + xx) and LAND_HEIGHT_MASK) = 0) then Land[y + xx, x - yy]:= Color;
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1086	if (((x - yy) and LAND_WIDTH_MASK) = 0) and (((y - xx) and LAND_HEIGHT_MASK) = 0) then Land[y - xx, x - yy]:= Color;
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1087	end;
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1088
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1089	procedure DrawLines(X1, Y1, X2, Y2, XX, YY: LongInt; color: Longword);
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1090	var
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1091	eX, eY, dX, dY: LongInt;
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1092	i, sX, sY, x, y, d: LongInt;
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1093	f: boolean;
7147 11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	1094	begin
7150 fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1095	eX:= 0;
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1096	eY:= 0;
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1097	dX:= X2 - X1;
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1098	dY:= Y2 - Y1;
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1099
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1100	if (dX > 0) then
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1101	sX:= 1
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1102	else
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1103	if (dX < 0) then
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1104	begin
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1105	sX:= -1;
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1106	dX:= -dX
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1107	end
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1108	else
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1109	sX:= dX;
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1110
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1111	if (dY > 0) then
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1112	sY:= 1
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1113	else
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1114	if (dY < 0) then
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1115	begin
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1116	sY:= -1;
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1117	dY:= -dY
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1118	end
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1119	else
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1120	sY:= dY;
7147 11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	1121
7150 fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1122	if (dX > dY) then
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1123	d:= dX
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1124	else
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1125	d:= dY;
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1126
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1127	x:= X1;
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1128	y:= Y1;
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1129
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1130	for i:= 0 to d do
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1131	begin
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1132	inc(eX, dX);
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1133	inc(eY, dY);
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1134
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1135	f:= eX > d;
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1136	if f then
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1137	begin
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1138	dec(eX, d);
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1139	inc(x, sX);
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1140	DrawDots(x, y, xx, yy, color)
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1141	end;
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1142	if (eY > d) then
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1143	begin
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1144	dec(eY, d);
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1145	inc(y, sY);
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1146	f:= true;
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1147	DrawDots(x, y, xx, yy, color)
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1148	end;
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1149
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1150	if not f then
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1151	DrawDots(x, y, xx, yy, color)
fba3b14ff746 This should make drawn maps rendering even more faster unc0rr parents: 7147 diff changeset	1152	end
7147 11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	1153	end;
11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	1154
11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	1155	procedure DrawThickLine(X1, Y1, X2, Y2, radius: LongInt; color: Longword);
11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	1156	var dx, dy, d: LongInt;
11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	1157	begin
11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	1158	dx:= 0;
11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	1159	dy:= Radius;
11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	1160	d:= 3 - 2 * Radius;
11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	1161	while (dx < dy) do
11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	1162	begin
11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	1163	DrawLines(x1, y1, x2, y2, dx, dy, color);
11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	1164	if (d < 0) then
11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	1165	d:= d + 4 * dx + 6
11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	1166	else
11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	1167	begin
11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	1168	d:= d + 4 * (dx - dy) + 10;
11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	1169	dec(dy)
11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	1170	end;
11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	1171	inc(dx)
11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	1172	end;
11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	1173	if (dx = dy) then
11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	1174	DrawLines(x1, y1, x2, y2, dx, dy, color);
11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	1175	end;
11b7b12e2b85 Render drawn maps 10-500 times faster unc0rr parents: 7035 diff changeset	1176
7268 3a61c53346a8 - Fix cake bug introduced in r2ccfc93c6b5e unc0rr parents: 7170 diff changeset	1177
3a61c53346a8 - Fix cake bug introduced in r2ccfc93c6b5e unc0rr parents: 7170 diff changeset	1178	procedure DumpLandToLog(x, y, r: LongInt);
3a61c53346a8 - Fix cake bug introduced in r2ccfc93c6b5e unc0rr parents: 7170 diff changeset	1179	var xx, yy, dx: LongInt;
3a61c53346a8 - Fix cake bug introduced in r2ccfc93c6b5e unc0rr parents: 7170 diff changeset	1180	s: shortstring;
3a61c53346a8 - Fix cake bug introduced in r2ccfc93c6b5e unc0rr parents: 7170 diff changeset	1181	begin
3a61c53346a8 - Fix cake bug introduced in r2ccfc93c6b5e unc0rr parents: 7170 diff changeset	1182	s[0]:= char(r * 2 + 1);
3a61c53346a8 - Fix cake bug introduced in r2ccfc93c6b5e unc0rr parents: 7170 diff changeset	1183	for yy:= y - r to y + r do
3a61c53346a8 - Fix cake bug introduced in r2ccfc93c6b5e unc0rr parents: 7170 diff changeset	1184	begin
3a61c53346a8 - Fix cake bug introduced in r2ccfc93c6b5e unc0rr parents: 7170 diff changeset	1185	for dx:= 0 to r*2 do
3a61c53346a8 - Fix cake bug introduced in r2ccfc93c6b5e unc0rr parents: 7170 diff changeset	1186	begin
3a61c53346a8 - Fix cake bug introduced in r2ccfc93c6b5e unc0rr parents: 7170 diff changeset	1187	xx:= dx - r + x;
3a61c53346a8 - Fix cake bug introduced in r2ccfc93c6b5e unc0rr parents: 7170 diff changeset	1188	if (xx = x) and (yy = y) then
3a61c53346a8 - Fix cake bug introduced in r2ccfc93c6b5e unc0rr parents: 7170 diff changeset	1189	s[dx + 1]:= 'X'
3a61c53346a8 - Fix cake bug introduced in r2ccfc93c6b5e unc0rr parents: 7170 diff changeset	1190	else if Land[yy, xx] > 255 then
3a61c53346a8 - Fix cake bug introduced in r2ccfc93c6b5e unc0rr parents: 7170 diff changeset	1191	s[dx + 1]:= 'O'
3a61c53346a8 - Fix cake bug introduced in r2ccfc93c6b5e unc0rr parents: 7170 diff changeset	1192	else if Land[yy, xx] > 0 then
3a61c53346a8 - Fix cake bug introduced in r2ccfc93c6b5e unc0rr parents: 7170 diff changeset	1193	s[dx + 1]:= '*'
3a61c53346a8 - Fix cake bug introduced in r2ccfc93c6b5e unc0rr parents: 7170 diff changeset	1194	else
3a61c53346a8 - Fix cake bug introduced in r2ccfc93c6b5e unc0rr parents: 7170 diff changeset	1195	s[dx + 1]:= '.'
3a61c53346a8 - Fix cake bug introduced in r2ccfc93c6b5e unc0rr parents: 7170 diff changeset	1196	end;
3a61c53346a8 - Fix cake bug introduced in r2ccfc93c6b5e unc0rr parents: 7170 diff changeset	1197	AddFileLog('Land dump: ' + s);
3a61c53346a8 - Fix cake bug introduced in r2ccfc93c6b5e unc0rr parents: 7170 diff changeset	1198	end;
3a61c53346a8 - Fix cake bug introduced in r2ccfc93c6b5e unc0rr parents: 7170 diff changeset	1199	end;
3a61c53346a8 - Fix cake bug introduced in r2ccfc93c6b5e unc0rr parents: 7170 diff changeset	1200
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	1201	end.

author	nemo
	Mon, 06 Aug 2012 10:18:57 -0400
changeset 7509	76e3a3fc17cd
parent 7492	3188794b9d87
child 8026	4a4f21070479
child 8579	d18bc19d780a
permissions	-rw-r--r--