hedgewars-draft: hedgewars/uLandGraphics.pas@ed23eba1a369 (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
2716 b9ca1bfca24f complete the replacement of init/free wrappers for every unit koda parents: 2695 diff changeset	30	function SweepDirty: boolean;
b9ca1bfca24f complete the replacement of init/free wrappers for every unit koda parents: 2695 diff changeset	31	function Despeckle(X, Y: LongInt): boolean;
3509 d72c2219595d Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag) nemo parents: 3236 diff changeset	32	function CheckLandValue(X, Y: LongInt; LandFlag: Word): boolean;
4377 43945842da0c Haven't found a better place than uIO for OutError unC0Rr parents: 4374 diff changeset	33	function DrawExplosion(X, Y, Radius: LongInt): Longword;
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	34	procedure DrawHLinesExplosions(ar: PRangeArray; Radius: LongInt; y, dY: LongInt; Count: Byte);
731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	35	procedure DrawTunnel(X, Y, dX, dY: hwFloat; ticks, HalfWidth: LongInt);
731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	36	procedure FillRoundInLand(X, Y, Radius: LongInt; Value: Longword);
511 2b5b9e00419d - Further work on new collisions implementation unc0rr parents: 505 diff changeset	37	procedure ChangeRoundInLand(X, Y, Radius: LongInt; doSet: boolean);
4367 f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	38	function LandBackPixel(x, y: LongInt): LongWord;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	39
520 e83dfb7ffead Teleportation tool unc0rr parents: 511 diff changeset	40	function TryPlaceOnLand(cpX, cpY: LongInt; Obj: TSprite; Frame: LongInt; doPlace: boolean): boolean;
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	41
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	42	implementation
4403 0dfe26f48ec1 uDebug unc0rr parents: 4377 diff changeset	43	uses SDLh, uLandTexture, uVariables, uUtils, uDebug;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	44
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	45	procedure FillCircleLines(x, y, dx, dy: LongInt; Value: Longword);
731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	46	var i: LongInt;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	47	begin
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	48	if ((y + dy) and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	49	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	50	if (Land[y + dy, i] and lfIndestructible) = 0 then
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	51	Land[y + dy, i]:= Value;
2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	52	if ((y - dy) and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	53	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	54	if (Land[y - dy, i] and lfIndestructible) = 0 then
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	55	Land[y - dy, i]:= Value;
2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	56	if ((y + dx) and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	57	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	58	if (Land[y + dx, i] and lfIndestructible) = 0 then
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	59	Land[y + dx, i]:= Value;
2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	60	if ((y - dx) and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	61	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	62	if (Land[y - dx, i] and lfIndestructible) = 0 then
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	63	Land[y - dx, i]:= Value;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	64	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	65
511 2b5b9e00419d - Further work on new collisions implementation unc0rr parents: 505 diff changeset	66	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	67	var i: LongInt;
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	68	begin
511 2b5b9e00419d - Further work on new collisions implementation unc0rr parents: 505 diff changeset	69	if not doSet then
2b5b9e00419d - Further work on new collisions implementation unc0rr parents: 505 diff changeset	70	begin
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	71	if ((y + dy) and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	72	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
1861 98de5dc5fda7 nemo: unc0rr parents: 1849 diff changeset	73	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	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
1861 98de5dc5fda7 nemo: unc0rr parents: 1849 diff changeset	76	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	77	if ((y + dx) and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	78	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
1861 98de5dc5fda7 nemo: unc0rr parents: 1849 diff changeset	79	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	80	if ((y - dx) and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	81	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
1861 98de5dc5fda7 nemo: unc0rr parents: 1849 diff changeset	82	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	83	end else
2b5b9e00419d - Further work on new collisions implementation unc0rr parents: 505 diff changeset	84	begin
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	85	if ((y + dy) and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	86	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	87	if (Land[y + dy, i] < 256) then
1861 98de5dc5fda7 nemo: unc0rr parents: 1849 diff changeset	88	inc(Land[y + dy, i]);
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	89	if ((y - dy) and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	90	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	91	if (Land[y - dy, i] < 256) then
1861 98de5dc5fda7 nemo: unc0rr parents: 1849 diff changeset	92	inc(Land[y - dy, i]);
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	93	if ((y + dx) and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	94	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	95	if (Land[y + dx, i] < 256) then
1861 98de5dc5fda7 nemo: unc0rr parents: 1849 diff changeset	96	inc(Land[y + dx, i]);
1753 2ccba26f1aa4 Apply nemo's world resize patch unc0rr parents: 1738 diff changeset	97	if ((y - dx) 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 - 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	99	if (Land[y - dx, i] < 256) then
1861 98de5dc5fda7 nemo: unc0rr parents: 1849 diff changeset	100	inc(Land[y - dx, i]);
511 2b5b9e00419d - Further work on new collisions implementation unc0rr parents: 505 diff changeset	101	end
504 13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	102	end;
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	103
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	104	procedure FillRoundInLand(X, Y, Radius: LongInt; Value: Longword);
731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	105	var dx, dy, d: LongInt;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	106	begin
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	107	dx:= 0;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	108	dy:= Radius;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	109	d:= 3 - 2 * Radius;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	110	while (dx < dy) do
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	111	begin
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	112	FillCircleLines(x, y, dx, dy, Value);
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	113	if (d < 0)
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	114	then d:= d + 4 * dx + 6
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	115	else begin
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	116	d:= d + 4 * (dx - dy) + 10;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	117	dec(dy)
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	118	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	119	inc(dx)
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	120	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	121	if (dx = dy) then FillCircleLines(x, y, dx, dy, Value);
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	122	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	123
511 2b5b9e00419d - Further work on new collisions implementation unc0rr parents: 505 diff changeset	124	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	125	var dx, dy, d: LongInt;
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	126	begin
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	127	dx:= 0;
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	128	dy:= Radius;
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	129	d:= 3 - 2 * Radius;
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	130	while (dx < dy) do
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	131	begin
511 2b5b9e00419d - Further work on new collisions implementation unc0rr parents: 505 diff changeset	132	ChangeCircleLines(x, y, dx, dy, doSet);
504 13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	133	if (d < 0)
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	134	then d:= d + 4 * dx + 6
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	135	else begin
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	136	d:= d + 4 * (dx - dy) + 10;
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	137	dec(dy)
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	138	end;
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	139	inc(dx)
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	140	end;
511 2b5b9e00419d - Further work on new collisions implementation unc0rr parents: 505 diff changeset	141	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	142	end;
13b6ebc53627 Fix collision info artifacts in Land array when two objects intersect unc0rr parents: 495 diff changeset	143
2603 abed6070a669 revert previous commit to remove a wip patch koda parents: 2602 diff changeset	144	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	145	var i, t: LongInt;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	146	begin
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	147	t:= y + dy;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	148	if (t and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	149	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	150	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	151	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	152	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	153	else
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	154	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	155
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	156	t:= y - dy;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	157	if (t and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	158	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	159	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	160	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	161	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	162	else
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	163	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	164
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	165	t:= y + dx;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	166	if (t and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	167	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	168	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	169	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	170	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	171	else
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	172	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	173
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	174	t:= y - dx;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	175	if (t and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	176	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	177	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	178	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	179	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	180	else
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	181	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	182
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	183	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	184
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	185	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	186	var i, t: LongInt;
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	187	cnt: Longword;
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	188	begin
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	189	cnt:= 0;
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	190	t:= y + dy;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	191	if (t and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	192	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	193	if ((Land[t, i] and lfBasic) <> 0) then
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	194	begin
e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	195	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	196	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	197	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	198	else
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	199	LandPixels[t div 2, i div 2]:= LandBackPixel(i, t)
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	200	end
4640 bc30434ae156 oops. hopefully unbreak maps while still preserving mask behaviour as before (basketball nets etc) nemo parents: 4635 diff changeset	201	else if not isMap or ((Land[t, i] and lfObject) <> 0) then
4635 62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	202	begin
62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	203	if (cReducedQuality and rqBlurryLand) = 0 then
62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	204	LandPixels[t, i]:= 0
62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	205	else
62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	206	LandPixels[t div 2, i div 2]:= 0
62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	207	end;
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	208
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	209	t:= y - dy;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	210	if (t and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	211	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	212	if ((Land[t, i] and lfBasic) <> 0) then
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	213	begin
e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	214	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	215	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	216	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	217	else
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	218	LandPixels[t div 2, i div 2]:= LandBackPixel(i, t)
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	219	end
4640 bc30434ae156 oops. hopefully unbreak maps while still preserving mask behaviour as before (basketball nets etc) nemo parents: 4635 diff changeset	220	else if not isMap or ((Land[t, i] and lfObject) <> 0) then
4635 62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	221	begin
62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	222	if (cReducedQuality and rqBlurryLand) = 0 then
62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	223	LandPixels[t, i]:= 0
62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	224	else
62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	225	LandPixels[t div 2, i div 2]:= 0
62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	226	end;
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	227
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	228	t:= y + dx;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	229	if (t and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	230	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	231	if ((Land[t, i] and lfBasic) <> 0) then
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	232	begin
e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	233	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	234	if (cReducedQuality and rqBlurryLand) = 0 then
4635 62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	235	LandPixels[t, i]:= LandBackPixel(i, t)
62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	236	else
62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	237	LandPixels[t div 2, i div 2]:= LandBackPixel(i, t)
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	238	end
4640 bc30434ae156 oops. hopefully unbreak maps while still preserving mask behaviour as before (basketball nets etc) nemo parents: 4635 diff changeset	239	else if not isMap or ((Land[t, i] and lfObject) <> 0) then
4635 62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	240	begin
62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	241	if (cReducedQuality and rqBlurryLand) = 0 then
4640 bc30434ae156 oops. hopefully unbreak maps while still preserving mask behaviour as before (basketball nets etc) nemo parents: 4635 diff changeset	242	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	243	else
4640 bc30434ae156 oops. hopefully unbreak maps while still preserving mask behaviour as before (basketball nets etc) nemo parents: 4635 diff changeset	244	LandPixels[t div 2, i div 2]:= 0
4635 62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	245	end;
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	246
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	247	t:= y - dx;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	248	if (t and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	249	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	250	if ((Land[t, i] and lfBasic) <> 0) then
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	251	begin
e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	252	inc(cnt);
e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	253	if (cReducedQuality and rqBlurryLand) = 0 then
e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	254	LandPixels[t, i]:= LandBackPixel(i, t)
3697 d5b30d6373fc remove trailing spaces from end of line koda parents: 3689 diff changeset	255	else
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	256	LandPixels[t div 2, i div 2]:= LandBackPixel(i, t)
e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	257	end
4640 bc30434ae156 oops. hopefully unbreak maps while still preserving mask behaviour as before (basketball nets etc) nemo parents: 4635 diff changeset	258	else if not isMap or ((Land[t, i] and lfObject) <> 0) then
4635 62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	259	begin
62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	260	if (cReducedQuality and rqBlurryLand) = 0 then
62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	261	LandPixels[t, i]:= 0
62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	262	else
62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	263	LandPixels[t div 2, i div 2]:= 0
62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	264	end;
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	265	FillLandCircleLinesBG:= cnt;
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	266	end;
0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	267
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	268	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	269	var i, t: LongInt;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	270	begin
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	271	t:= y + dy;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	272	if (t and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	273	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
4634 784e2df9e79a Visual tweaks for snow nemo parents: 4403 diff changeset	274	if (Land[t, i] and (lfBasic or 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	275	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	276	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	277	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	278	else
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	279	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	280
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	281	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	282	//Despeckle(i, t);
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	283	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	284	end;
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	285
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	286	t:= y - dy;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	287	if (t and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	288	for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do
4634 784e2df9e79a Visual tweaks for snow nemo parents: 4403 diff changeset	289	if (Land[t, i] and (lfBasic or 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	290	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	291	if (cReducedQuality and rqBlurryLand) = 0 then
3697 d5b30d6373fc remove trailing spaces from end of line koda parents: 3689 diff changeset	292	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	293	else
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	294	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	295	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	296	//Despeckle(i, t);
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	297	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	298	end;
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	299
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	300	t:= y + dx;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	301	if (t and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	302	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
4634 784e2df9e79a Visual tweaks for snow nemo parents: 4403 diff changeset	303	if (Land[t, i] and (lfBasic or 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	304	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	305	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	306	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	307	else
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	308	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	309
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	310	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	311	//Despeckle(i, t);
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	312	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	313	end;
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	314
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	315	t:= y - dx;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	316	if (t and LAND_HEIGHT_MASK) = 0 then
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	317	for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do
4634 784e2df9e79a Visual tweaks for snow nemo parents: 4403 diff changeset	318	if (Land[t, i] and (lfBasic or 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	319	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	320	if (cReducedQuality and rqBlurryLand) = 0 then
3697 d5b30d6373fc remove trailing spaces from end of line koda parents: 3689 diff changeset	321	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	322	else
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	323	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	324
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	325	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	326	//Despeckle(i, y - dy);
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	327	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	328	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	329	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	330
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	331	function DrawExplosion(X, Y, Radius: LongInt): Longword;
2603 abed6070a669 revert previous commit to remove a wip patch koda parents: 2602 diff changeset	332	var dx, dy, ty, tx, d: LongInt;
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	333	cnt: Longword;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	334	begin
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	335
0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	336	// draw background land texture
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	337	begin
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	338	cnt:= 0;
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	339	dx:= 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	340	dy:= Radius;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	341	d:= 3 - 2 * Radius;
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	342
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	343	while (dx < dy) do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	344	begin
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	345	inc(cnt, FillLandCircleLinesBG(x, y, dx, dy));
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	346	if (d < 0)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	347	then d:= d + 4 * dx + 6
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	348	else begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	349	d:= d + 4 * (dx - dy) + 10;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	350	dec(dy)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	351	end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	352	inc(dx)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	353	end;
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	354	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	355	end;
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	356
0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	357	// draw a hole in land
2733 52a5a160566f Engine: smxx parents: 2716 diff changeset	358	if Radius > 20 then
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	359	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	360	dx:= 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	361	dy:= Radius - 15;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	362	d:= 3 - 2 * dy;
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	363
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	364	while (dx < dy) do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	365	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	366	FillLandCircleLines0(x, y, dx, dy);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	367	if (d < 0)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	368	then d:= d + 4 * dx + 6
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	369	else begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	370	d:= d + 4 * (dx - dy) + 10;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	371	dec(dy)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	372	end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	373	inc(dx)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	374	end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	375	if (dx = dy) then FillLandCircleLines0(x, y, dx, dy);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	376	end;
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	377
1849 2a989e5abda6 4 utilities by nemo unc0rr parents: 1809 diff changeset	378	// 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	379	FillRoundInLand(X, Y, Radius, 0);
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	380
0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	381	// draw explosion border
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	382	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	383	inc(Radius, 4);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	384	dx:= 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	385	dy:= Radius;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	386	d:= 3 - 2 * Radius;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	387	while (dx < dy) do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	388	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	389	FillLandCircleLinesEBC(x, y, dx, dy);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	390	if (d < 0)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	391	then d:= d + 4 * dx + 6
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	392	else begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	393	d:= d + 4 * (dx - dy) + 10;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	394	dec(dy)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	395	end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	396	inc(dx)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	397	end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	398	if (dx = dy) then FillLandCircleLinesEBC(x, y, dx, dy);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	399	end;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 345 diff changeset	400
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	401	tx:= Max(X - Radius - 1, 0);
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	402	dx:= Min(X + Radius + 1, LAND_WIDTH) - tx;
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	403	ty:= Max(Y - Radius - 1, 0);
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	404	dy:= Min(Y + Radius + 1, LAND_HEIGHT) - ty;
3689 e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	405	UpdateLandTexture(tx, dx, ty, dy);
e2be39ee19f0 Engine: smaxx parents: 3608 diff changeset	406	DrawExplosion:= cnt
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	407	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	408
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	409	procedure DrawHLinesExplosions(ar: PRangeArray; Radius: LongInt; y, dY: LongInt; Count: Byte);
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	410	var tx, ty, i: LongInt;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	411	begin
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	412	for i:= 0 to Pred(Count) do
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	413	begin
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	414	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	415	for tx:= Max(0, ar^[i].Left - Radius) to Min(LAND_WIDTH, ar^[i].Right + Radius) do
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	416	if (Land[ty, tx] and lfBasic) <> 0 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	417	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	418	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	419	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	420	LandPixels[ty div 2, tx div 2]:= LandBackPixel(tx, ty)
4635 62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	421	else if not isMap then
62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	422	begin
62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	423	if (cReducedQuality and rqBlurryLand) = 0 then
62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	424	LandPixels[ty, tx]:= 0
62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	425	else
62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	426	LandPixels[ty div 2, tx div 2]:= 0
62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	427	end;
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	428	inc(y, dY)
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	429	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	430
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	431	inc(Radius, 4);
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 345 diff changeset	432	dec(y, Count * dY);
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	433
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	434	for i:= 0 to Pred(Count) do
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 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
4634 784e2df9e79a Visual tweaks for snow nemo parents: 4403 diff changeset	438	if (Land[ty, tx] and (lfBasic or 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	439	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	440	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	441	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	442	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	443	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	444
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	445	Land[ty, tx]:= Land[ty, tx] or lfDamaged;
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	446	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	447	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	448	inc(y, dY)
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	449	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	450
818 635e58295079 Fix drill bug unc0rr parents: 772 diff changeset	451
1807 795f97007833 Split land texture into small ones: unc0rr parents: 1806 diff changeset	452	UpdateLandTexture(0, LAND_WIDTH, 0, LAND_HEIGHT)
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	453	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	454
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	455	//
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	456	// - (dX, dY) - direction, vector of length = 0.5
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	457	//
371 731ad6d27bd1 integer -> LongInt unc0rr parents: 358 diff changeset	458	procedure DrawTunnel(X, Y, dX, dY: hwFloat; ticks, HalfWidth: LongInt);
358 236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	459	var nx, ny, dX8, dY8: hwFloat;
1809 77923087a1ce Some optimization of land texture updating unc0rr parents: 1807 diff changeset	460	i, t, tx, ty, stX, stY, ddy, ddx: Longint;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	461	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	462	stY:= hwRound(Y);
1809 77923087a1ce Some optimization of land texture updating unc0rr parents: 1807 diff changeset	463	stX:= hwRound(X);
772 e8d530ca77be Don't update all land texture when drawing tunnel (saves video throughput) unc0rr parents: 769 diff changeset	464
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	465	nx:= X + dY * (HalfWidth + 8);
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	466	ny:= Y - dX * (HalfWidth + 8);
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	467
358 236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	468	dX8:= dX * 8;
236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	469	dY8:= dY * 8;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	470	for i:= 0 to 7 do
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	471	begin
358 236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	472	X:= nx - dX8;
236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	473	Y:= ny - dY8;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	474	for t:= -8 to ticks + 8 do
2666 2b8c8f16421e update SDLMain.m/.h to latest version koda parents: 2648 diff changeset	475	begin
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	476	X:= X + dX;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	477	Y:= Y + dY;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	478	tx:= hwRound(X);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	479	ty:= hwRound(Y);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	480	if ((ty and LAND_HEIGHT_MASK) = 0) and
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	481	((tx and LAND_WIDTH_MASK) = 0) and
4635 62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	482	((Land[ty, tx] and (lfBasic or 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	483	begin
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	484	Land[ty, tx]:= Land[ty, tx] or lfDamaged;
4635 62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	485	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	486	LandPixels[ty, tx]:= cExplosionBorderColor
4635 62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	487	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	488	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	489	end
2666 2b8c8f16421e update SDLMain.m/.h to latest version koda parents: 2648 diff changeset	490	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	491	nx:= nx - dY;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	492	ny:= ny + dX;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	493	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	494
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	495	for i:= -HalfWidth to HalfWidth do
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	496	begin
358 236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	497	X:= nx - dX8;
236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	498	Y:= ny - dY8;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	499	for t:= 0 to 7 do
2666 2b8c8f16421e update SDLMain.m/.h to latest version koda parents: 2648 diff changeset	500	begin
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	501	X:= X + dX;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	502	Y:= Y + dY;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	503	tx:= hwRound(X);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	504	ty:= hwRound(Y);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	505	if ((ty and LAND_HEIGHT_MASK) = 0) and
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	506	((tx and LAND_WIDTH_MASK) = 0) and
4635 62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	507	((Land[ty, tx] and (lfBasic or 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	508	begin
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	509	Land[ty, tx]:= Land[ty, tx] or lfDamaged;
4640 bc30434ae156 oops. hopefully unbreak maps while still preserving mask behaviour as before (basketball nets etc) nemo parents: 4635 diff changeset	510	if (cReducedQuality and rqBlurryLand) = 0 then
bc30434ae156 oops. hopefully unbreak maps while still preserving mask behaviour as before (basketball nets etc) nemo parents: 4635 diff changeset	511	LandPixels[ty, tx]:= cExplosionBorderColor
bc30434ae156 oops. hopefully unbreak maps while still preserving mask behaviour as before (basketball nets etc) nemo parents: 4635 diff changeset	512	else
4635 62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	513	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	514	end
2666 2b8c8f16421e update SDLMain.m/.h to latest version koda parents: 2648 diff changeset	515	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	516	X:= nx;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	517	Y:= ny;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	518	for t:= 0 to ticks do
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	519	begin
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	520	X:= X + dX;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	521	Y:= Y + dY;
351 29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 345 diff changeset	522	tx:= hwRound(X);
29bc9c36ad5f Fixed-point arithmetics in engine. unc0rr parents: 345 diff changeset	523	ty:= hwRound(Y);
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	524	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	525	begin
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	526	if (Land[ty, tx] and lfBasic) <> 0 then
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	527	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	528	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	529	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	530	LandPixels[ty div 2, tx div 2]:= LandBackPixel(tx, ty)
4640 bc30434ae156 oops. hopefully unbreak maps while still preserving mask behaviour as before (basketball nets etc) nemo parents: 4635 diff changeset	531	else if not isMap or ((Land[ty, tx] and lfObject) <> 0) then
4635 62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	532	begin
4640 bc30434ae156 oops. hopefully unbreak maps while still preserving mask behaviour as before (basketball nets etc) nemo parents: 4635 diff changeset	533	if (cReducedQuality and rqBlurryLand) = 0 then
4635 62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	534	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	535	else
4635 62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	536	LandPixels[ty div 2, tx div 2]:= 0
62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	537	end;
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	538
2647 0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	539	Land[ty, tx]:= 0;
0e1208e92dfe Smaxx patch with tuning by me: unc0rr parents: 2646 diff changeset	540	end
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	541	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	542	for t:= 0 to 7 do
2666 2b8c8f16421e update SDLMain.m/.h to latest version koda parents: 2648 diff changeset	543	begin
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	544	X:= X + dX;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	545	Y:= Y + dY;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	546	tx:= hwRound(X);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	547	ty:= hwRound(Y);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	548	if ((ty and LAND_HEIGHT_MASK) = 0) and
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	549	((tx and LAND_WIDTH_MASK) = 0) and
4635 62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	550	((Land[ty, tx] and (lfBasic or lfObject)) <> 0) then
3509 d72c2219595d Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag) nemo parents: 3236 diff changeset	551	begin
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	552	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	553	if (cReducedQuality and rqBlurryLand) = 0 then
4635 62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	554	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	555	else
4635 62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	556	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	557	end
2666 2b8c8f16421e update SDLMain.m/.h to latest version koda parents: 2648 diff changeset	558	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	559	nx:= nx - dY;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	560	ny:= ny + dX;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	561	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	562
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	563	for i:= 0 to 7 do
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	564	begin
358 236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	565	X:= nx - dX8;
236bbd12d4d9 - New Land Generator unc0rr parents: 351 diff changeset	566	Y:= ny - dY8;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	567	for t:= -8 to ticks + 8 do
2666 2b8c8f16421e update SDLMain.m/.h to latest version koda parents: 2648 diff changeset	568	begin
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	569	X:= X + dX;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	570	Y:= Y + dY;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	571	tx:= hwRound(X);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	572	ty:= hwRound(Y);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	573	if ((ty and LAND_HEIGHT_MASK) = 0) and
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	574	((tx and LAND_WIDTH_MASK) = 0) and
4635 62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	575	((Land[ty, tx] and (lfBasic or 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	576	begin
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	577	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	578	if (cReducedQuality and rqBlurryLand) = 0 then
4635 62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	579	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	580	else
4635 62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	581	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	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
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	588	tx:= Max(stX - HalfWidth * 2 - 4 - abs(hwRound(dX * ticks)), 0);
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	589	ty:= Max(stY - HalfWidth * 2 - 4 - abs(hwRound(dY * ticks)), 0);
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	590	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	591	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	592
77923087a1ce Some optimization of land texture updating unc0rr parents: 1807 diff changeset	593	UpdateLandTexture(tx, ddx, ty, ddy)
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	594	end;
f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	595
520 e83dfb7ffead Teleportation tool unc0rr parents: 511 diff changeset	596	function TryPlaceOnLand(cpX, cpY: LongInt; Obj: TSprite; Frame: LongInt; doPlace: boolean): boolean;
2235 79c9542c1058 multi-column support nemo parents: 2167 diff changeset	597	var X, Y, bpp, h, w, row, col, numFramesFirstCol: LongInt;
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	598	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	599	Image: PSDL_Surface;
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	600	begin
2235 79c9542c1058 multi-column support nemo parents: 2167 diff changeset	601	numFramesFirstCol:= SpritesData[Obj].imageHeight div SpritesData[Obj].Height;
79c9542c1058 multi-column support nemo parents: 2167 diff changeset	602
769 788efc1d649f - Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization unc0rr parents: 768 diff changeset	603	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	604	Image:= SpritesData[Obj].Surface;
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	605	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	606	h:= SpritesData[Obj].Height;
2235 79c9542c1058 multi-column support nemo parents: 2167 diff changeset	607	row:= Frame mod numFramesFirstCol;
79c9542c1058 multi-column support nemo parents: 2167 diff changeset	608	col:= Frame div numFramesFirstCol;
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	609
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	610	if SDL_MustLock(Image) then
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	611	SDLTry(SDL_LockSurface(Image) >= 0, true);
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	612
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	613	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	614	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	615	// Check that sprite fits free space
2236 af8fc3311748 the -1 was a bad idea nemo parents: 2235 diff changeset	616	p:= @(PByteArray(Image^.pixels)^[ Image^.pitch * row * h + col * w * 4 ]);
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	617	case bpp of
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	618	4: for y:= 0 to Pred(h) do
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	619	begin
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	620	for x:= 0 to Pred(w) do
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	621	if PLongword(@(p^[x * 4]))^ <> 0 then
3749 d0920e92008e Engine: smaxx parents: 3697 diff changeset	622	if ((cpY + y) <= Longint(topY)) or
d0920e92008e Engine: smaxx parents: 3697 diff changeset	623	((cpY + y) >= LAND_HEIGHT) or
d0920e92008e Engine: smaxx parents: 3697 diff changeset	624	((cpX + x) <= Longint(leftX)) or
d0920e92008e Engine: smaxx parents: 3697 diff changeset	625	((cpX + x) >= Longint(rightX)) or
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	626	(Land[cpY + y, cpX + x] <> 0) then
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	627	begin
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	628	if SDL_MustLock(Image) then
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	629	SDL_UnlockSurface(Image);
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	630	exit(false)
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	631	end;
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	632	p:= @(p^[Image^.pitch]);
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	633	end;
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	634	end;
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	635
520 e83dfb7ffead Teleportation tool unc0rr parents: 511 diff changeset	636	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	637	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	638	begin
788efc1d649f - Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization unc0rr parents: 768 diff changeset	639	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	640	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	641	exit
788efc1d649f - Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization unc0rr parents: 768 diff changeset	642	end;
520 e83dfb7ffead Teleportation tool unc0rr parents: 511 diff changeset	643
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	644	// Checked, now place
2236 af8fc3311748 the -1 was a bad idea nemo parents: 2235 diff changeset	645	p:= @(PByteArray(Image^.pixels)^[ Image^.pitch * row * h + col * w * 4 ]);
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	646	case bpp of
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	647	4: for y:= 0 to Pred(h) do
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	648	begin
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	649	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	650	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	651	begin
3519 56cbc035b74b rename flags nemo parents: 3518 diff changeset	652	Land[cpY + y, cpX + x]:= lfObject;
3596 51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	653	if (cReducedQuality and rqBlurryLand) = 0 then
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	654	LandPixels[cpY + y, cpX + x]:= PLongword(@(p^[x * 4]))^
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	655	else
51062794ed01 Store some calcs to speed up uLandGraphics a tad nemo parents: 3595 diff changeset	656	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	657	end;
409 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	if SDL_MustLock(Image) then
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	662	SDL_UnlockSurface(Image);
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	663
4374 bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	664	x:= Max(cpX, leftX);
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	665	w:= Min(cpX + Image^.w, LAND_WIDTH) - x;
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	666	y:= Max(cpY, topY);
bcefeeabaa33 Move some stuff from uMisc to uUtils unC0Rr parents: 4367 diff changeset	667	h:= Min(cpY + Image^.h, LAND_HEIGHT) - y;
1807 795f97007833 Split land texture into small ones: unc0rr parents: 1806 diff changeset	668	UpdateLandTexture(x, w, y, h)
409 4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	669	end;
4f1841929ccc Construction tool unc0rr parents: 393 diff changeset	670
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	671	// 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	672	function Despeckle(X, Y: LongInt): boolean;
00e8dadce69a Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays unc0rr parents: 1066 diff changeset	673	var nx, ny, i, j, c: LongInt;
00e8dadce69a Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays unc0rr parents: 1066 diff changeset	674	begin
3521 96a502730e81 Remove redundant test, add some temp variables to speed up the expensive CheckLand nemo parents: 3519 diff changeset	675	if ((Land[Y, X] and lfDamaged) <> 0) and ((Land[Y, X] and lfIndestructible) = 0) then // check neighbours
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	676	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	677	c:= 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	678	for i:= -1 to 1 do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	679	for j:= -1 to 1 do
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	680	if (i <> 0) or (j <> 0) then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	681	begin
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	682	ny:= Y + i;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	683	nx:= X + j;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	684	if ((ny and LAND_HEIGHT_MASK) = 0) and ((nx and LAND_WIDTH_MASK) = 0) then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	685	if Land[ny, nx] > 255 then
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	686	inc(c);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	687	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	688
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	689	if c < 4 then // 0-3 neighbours
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	690	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	691	if (cReducedQuality and rqBlurryLand) = 0 then
4635 62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	692	begin
3697 d5b30d6373fc remove trailing spaces from end of line koda parents: 3689 diff changeset	693	if (Land[Y, X] and lfBasic) <> 0 then
d5b30d6373fc remove trailing spaces from end of line koda parents: 3689 diff changeset	694	LandPixels[Y, X]:= LandBackPixel(X, Y)
4640 bc30434ae156 oops. hopefully unbreak maps while still preserving mask behaviour as before (basketball nets etc) nemo parents: 4635 diff changeset	695	else if not isMap or ((Land[Y, X] and lfObject) <> 0) then
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	696	LandPixels[Y, X]:= 0
4635 62d0873459e5 more tweaking land graphics due to snow nemo parents: 4634 diff changeset	697	end
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	698	else
3697 d5b30d6373fc remove trailing spaces from end of line koda parents: 3689 diff changeset	699	if (Land[Y, X] and lfBasic) <> 0 then
d5b30d6373fc remove trailing spaces from end of line koda parents: 3689 diff changeset	700	LandPixels[Y div 2, X div 2]:= LandBackPixel(X, Y)
4640 bc30434ae156 oops. hopefully unbreak maps while still preserving mask behaviour as before (basketball nets etc) nemo parents: 4635 diff changeset	701	else if not isMap or ((Land[Y, X] and lfObject) <> 0) then
3595 341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	702	LandPixels[Y div 2, X div 2]:= 0;
341e407e3754 partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode) koda parents: 3554 diff changeset	703
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	704	Land[Y, X]:= 0;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	705	exit(true);
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	706	end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	707	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	708	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	709	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	710
1792 c30c6944bd49 engine part of nemo's patch unc0rr parents: 1761 diff changeset	711	function SweepDirty: boolean;
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	712	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	713	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	714	begin
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2666 diff changeset	715	bRes:= false;
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	716	reCheck:= true;
1792 c30c6944bd49 engine part of nemo's patch unc0rr parents: 1761 diff changeset	717
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	718	while recheck do
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	719	begin
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	720	recheck:= false;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	721	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	722	begin
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	723	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	724	begin
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	725	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	726	begin
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	727	updateBlock:= false;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	728	resweep:= true;
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	729	ty:= y * 32;
99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	730	tx:= x * 32;
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	731	while(resweep) do
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	732	begin
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	733	resweep:= false;
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	734	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	735	for xx:= tx to tx + 31 do
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	736	if Despeckle(xx, yy) then
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	737	begin
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	738	bRes:= true;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	739	updateBlock:= true;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	740	resweep:= true;
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	741	if (yy = ty) and (y > 0) then
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	742	begin
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	743	LandDirty[y-1, x]:= 1;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	744	recheck:= true;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	745	end
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	746	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	747	begin
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	748	LandDirty[y+1, x]:= 1;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	749	recheck:= true;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	750	end;
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	751	if (xx = tx) and (x > 0) then
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	752	begin
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	753	LandDirty[y, x-1]:= 1;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	754	recheck:= true;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	755	end
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	756	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	757	begin
3601 8a74c9ceaf71 Revert most of optimisation except for some obvious fixes to errors someone or other introduced. nemo parents: 3596 diff changeset	758	LandDirty[y, x+1]:= 1;
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	759	recheck:= true;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	760	end
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	761	end;
066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	762	end;
3602 99c93fa258d6 Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed nemo parents: 3601 diff changeset	763	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	764	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	765	end;
2948 3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	766	end;
3f21a9dc93d0 Replace tabs with spaces using 'expand -t 4' command unc0rr parents: 2741 diff changeset	767	end;
3554 066faceb977d Extend pixel sweep to recheck neighbours if erasing on edges nemo parents: 3521 diff changeset	768	end;
1792 c30c6944bd49 engine part of nemo's patch unc0rr parents: 1761 diff changeset	769
2695 ed789a7ef68d makes freepascal code compatible with OBJFPC mode koda parents: 2666 diff changeset	770	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	771	end;
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	772
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	773	// 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	774	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	775	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	776	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	777	end;
4367 f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	778
f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	779	function LandBackPixel(x, y: LongInt): LongWord;
f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	780	var p: PLongWordArray;
f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	781	begin
f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	782	if LandBackSurface = nil then LandBackPixel:= 0
f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	783	else
f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	784	begin
f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	785	p:= LandBackSurface^.pixels;
f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	786	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	787	end
f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	788	end;
f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	789
f4a0ec067601 uLand isn't that important to them unc0rr parents: 4359 diff changeset	790
184 f97a7a3dc8f6 - Update more headers unc0rr parents: 109 diff changeset	791	end.

author	jose1711
	Thu, 23 Dec 2010 20:32:45 +0100
changeset 4651	ed23eba1a369
parent 4640	bc30434ae156
child 4659	ce5897f53072
permissions	-rw-r--r--