hedgewars-draft: hedgewars/uLandGraphics.pas@458d9854c679 (annotated)

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

author	Palewolf
	Fri, 31 Dec 2010 00:37:39 +0100
changeset 4791	458d9854c679
parent 4700	e8fd20b2d66b
child 4886	e3e5362a308e
permissions	-rw-r--r--