next »

[Codestar]

Here's a current screenshot of my game, "Mine to the sky". My game builds levels using 32 x 32 tile templates and compiles them into a 2D array that is 128 x 128, like the image attached below. This array holds values of 0(air) and 1(dirt).


Really want to add different harder to break types of dirt blocks to the existing generated levels, but I'm having some trouble with trying to generate a height map from an existing 2D Array. I'm not sure how I could generate a height map with the existing 2D array "Mask".

I'd like to figure out how to do something like this with the dirt blocks, but figuring out how to do it with an array that's already been generated is a big headache.


Basically lets say I have a map like this, but with a more randomized pattern.
[
    [0, 0, 0, 0, 0, 0, 0, 0, 0],
    [0, 1, 1, 1, 1, 1, 1, 1, 0],
    [0, 1, 1, 1, 1, 1, 1, 1, 0],
    [0, 1, 1, 1, 1, 1, 1, 1, 0],
    [0, 1, 1, 1, 1, 1, 1, 1, 0],
    [0, 1, 1, 1, 1, 1, 1, 1, 0],
    [0, 1, 1, 1, 1, 1, 1, 1, 0],
    [0, 0, 0, 0, 0, 0, 0, 0, 0]
]

How would I make it so it had a "peak" in it's data that gradually sloped down until it hit "air"?
Something like this, but with a more randomized pattern.

[
    [0, 0, 0, 0, 0, 0, 0, 0, 0],
    [0, 1, 1, 1, 1, 1, 1, 1, 0],
    [0, 1, 2, 2, 2, 2, 2, 2, 0],
    [0, 1, 2, 3, 3, 3, 3, 2, 0],
    [0, 1, 2, 3, 3, 3, 3, 2, 0],
    [0, 1, 2, 2, 2, 2, 2, 2, 0],
    [0, 1, 1, 1, 1, 1, 1, 1, 0],
    [0, 0, 0, 0, 0, 0, 0, 0, 0]
]

If anyone has any suggestions I would really appreciate it.

[Layl]

I would use perlin or simplex noise for this, example in C#-alike pseudocode:

Code:

var multiplier = 5;

foreach(tile in tiles)
{
    var noise = perlin.GetValue(tile.X, tile.Y, 0.5f); // often perlin noise libraries only give you GetValue(x, y, z)
    var normalizedRaw = (noise + 1.0f) * 0.5; // perlin is in a range of -1 -> 1 usually BUT NOT ALWAYS, we need a 0-1 range here
    var normalized = Math.Range(, 0.0f, 1.0f); // Math.Range does not actually exist but you can see sort of what it does
    tile.Value = tile.Value * noise * multiplier;
}

If you want to make it slope down until it hits air, you also need to clamp or multiply the eventual value depending on the distance from the nearest air block.

[surt]

You'll want to do a distance transform of your mask to get the blended transition, then multiply it by your pattern to add the detailing.

[Codestar]

You'll want to do a distance transform of your mask to get the blended transition, then multiply it by your pattern to add the detailing.

How would I pick what parts of my 2D array are the "peaks" that it could blend down from? or would I even need "peaks" if I used a euclidean distance transform?

[oodavid]

If you are starting with a 2d array as mentioned, why not loop and run something like this:

X = own value
N = sum of all neighbours
A = Math.floor(N/4)
if(X<=A){
  X++
}

Which is essentially a variation of Pascale's triangle.

[BorisTheBrave]

Computing the distance transform for the manhattan distance metric. Here's an algorithm (essentially Dijkstra's, just simplified for you):

Code:

construct a new 2d array to store distance, and initialize every cell with zero
for each empty tile, t:
  set each adjacent solid tile's distance to 1
d = 1
repeat indefinitely:
  for each solid tile with distance d:
    set each adjacent solid tile with distance 0 to d + 1
  if no tiles were updated, exit loop
  d += 1

The easy way to loop over solid tiles with distance d is to just loop over all tiles and ignore those you don't want. Somewhat faster would be to record the set of tiles updated in each loop, and then loop over those next time round.

Note in your case you can probably terminate the loop after 10 iterations as anything more than 10 tiles from empty air is unlikely to be on the screen, so needn't have any variation.

[surt]

How would I pick what parts of my 2D array are the "peaks" that it could blend down from? or would I even need "peaks" if I used a euclidean distance transform?

You don't pick the peaks, the distance transform does. They will be the areas furthest from an edge.

EDIT:
Interactive demo of a rather sexy constant time distance transform method. Maths is way over my head though.  

[Codestar]

Thanks a lot guys, I was able to implement the distance transform algorithm and it worked perfectly!

[BorisTheBrave]

I'm glad you've got something you are happy with, but I can clearly see there are bugs in your implementation. The interior squares are somtimes only a single brick from the edge, sometimes many bricks. The point was to get a uniform distance!

[Layl]

I'm glad you've got something you are happy with, but I can clearly see there are bugs in your implementation. The interior squares are somtimes only a single brick from the edge, sometimes many bricks. The point was to get a uniform distance!

Nope, in the original post he asked for a bit of a randomized system, which is why I suggested perlin noise.

[BorisTheBrave]

Ah, I expect you are right.

[Codestar]

I'm glad you've got something you are happy with, but I can clearly see there are bugs in your implementation. The interior squares are somtimes only a single brick from the edge, sometimes many bricks. The point was to get a uniform distance!

You're actually quite right, there were a few bugs in my first implementation that I ironed them out after posting that screenshot. Now I have uniform distance working. You have a keen eye my friend.