Thread: Java light source simulation

I'm trying to make a light source simulation and it almost works. It's a 2D simulation, there are wall tiles in front of a lamp. When removing a wall tile the light shines through the hole. When removing a tile it works. But I don't know how to update it correctly when placing a wall. When removing or placing a wall, the updateLight method is called.

public static void updateLight(int x, int y)
	{
		byte myLight = getLight(x, y);
 
		if (getWall(x, y) == null) //Checks if there's a wall behind, if not it sets the light at this position to the max light and updates spaces next to this space.
		{
			byte lightPower = 6;
			setLight(x, y, lightPower);
			if (getLight(x - 1, y) < lightPower-1)
			{
				setLight(x - 1, y, (byte)(lightPower-1));
				if (getWall(x - 1, y) != null)
					updateLight(x - 1, y);
			}
			if (getLight(x + 1, y) < lightPower-1)
			{
				setLight(x + 1, y, (byte)(lightPower-1));
				if (getWall(x + 1, y) != null)
					updateLight(x + 1, y);
			}
			if (getLight(x, y - 1) < lightPower-1)
			{
				setLight(x, y - 1, (byte)(lightPower-1));
				if (getWall(x, y - 1) != null)
					updateLight(x, y - 1);
			}
			if (getLight(x, y + 1) < lightPower-1)
			{
				setLight(x, y + 1, (byte)(lightPower-1));
				if (getWall(x, y + 1) != null)
					updateLight(x, y + 1);
			}
		}
		else
		{
			if (myLight > 12) // If there's a wall behind it shouldn't be able to have the max light.
			{
				setLight(x, y, (byte) 12);
			}
			if (myLight > 0) //If the own light is greater than 0 it checks if the spaces next to it are less lit then this space - 1. If so, it changes the light to the own light -1 and updates it.
			{
				byte light = getLight(x, y);
				if (getLight(x - 1, y) < light - 1)
				{
					setLight(x - 1, y, (byte) (light - 1));
					if (getWall(x - 1, y) != null)
						updateLight(x - 1, y);
				}
				if (getLight(x + 1, y) < light - 1)
				{
					setLight(x + 1, y, (byte) (light - 1));
					if (getWall(x + 1, y) != null)
						updateLight(x + 1, y);
				}
				if (getLight(x, y - 1) < light - 1)
				{
					setLight(x, y - 1, (byte) (light - 1));
					if (getWall(x, y - 1) != null)
						updateLight(x, y - 1);
				}
				if (getLight(x, y + 1) < light - 1)
				{
					setLight(x, y + 1, (byte) (light - 1));
					if (getWall(x, y + 1) != null)
						updateLight(x, y + 1);
				}
			}
		}
	}

getWall returns a wall object, but I'm only checking if there's a wall or not (null). getLight returns the light value (0 - 13) where 0 is no light and 13 is max light and setLights sets it.
How can I update the placing correctly? And how can I update it correctly when the light power of the lamp changes?

Can you explain the logic that you are trying to write code for?
For example what does this mean:

update it correctly when the light power of the lamp changes

What is a "corrrect update" and how is it related to the light power?

What logic does the code need to do that?

when placing a wall, but it should unlight the spaces, without unliting the spaces that are still it by other sources.

Ok, what needs to be considered as you work on the logic for the program?
What determines what spaces are lite by other sources? How will the code detect that condition and react correctly?

Ok. If there is a hole, the light shines full strength there and with a -1 power at the (up to) 8 adjacent squares.

How far the light reaches

Does that mean the light goes past the adjacent squares? What determines how many squares it goes to?

Would the light intensity be decreased for each "ring" of squares around the hole?
The first ring could have 8 squares.
The next ring could have 18(?) squares
The next ring could have 26(?) squares.

There would NOT be rays pointing out from the hole. The decrease in intensity would be by ring.

If there are overlapping rings from different holes, would the intensity would be additive?

The light of the space is the light of the most lit space

That would mean that there would have to be several passes made for a square to see which hole is closer and brighter to know which hole to use to set the light for that square.
Seems like the light should be additive which would be simpler.

not in a ring form.

What does that mean? The light only shines in rays in the horizontal and vertical directions? The results will be a cross.

That's not a ring form, but also not a cross.

What is the algorithm for computing the intensity for adjacent squares?

The light of the space is the light of the most lit space next to it

Can you give an example of a square that has two holes near it, one closer than the other on different sides.
Does what you said say that only one of the holes will be used to determine the intensity at the square. The intensity will not be additive.
If the light is not additive, then the code needs to find which hole to use to set the intensity.

--- Update ---

The darker space is not taking the light from the lighter space, it's the opposite.

Does that mean:
The lighter space is taking the light from the darker space.
That is very confusing.

I think it'd be easier to visualize if you used a 2D array of digits to show the light intensities for each square.
For example:
00100
00300
13531
00300
00100

Will the code be working with 2D arrays?
Then it should be easier when talking about what the code is supposed to do to use 2D arrays of digits as I posted in post#20

Sorry, I don't connect to other sites.

the light is a 2D byte array, only the wall is a 2D Wall array.

So, the code is working with 2D arrays.

What are the rules for setting the lightedness for squares when there is a light source (hole) at a square in the array?
How do those rules change when there is more than one light source?