C# on AnanaSeek4Jam

First attempt on island generator

Thu, 25 Aug 2022 00:00:00 +0000

Recently I created a versatile system to generate islands in Unity and want to share my experience. There were technical issues, that are not so easy to solve, so I decided to describe the algorithm. There is no main code provided, because I just want to explain ways to fix some common problems, that may occur in many other projects, plus my code is not perfect for sure.

Implementation

Stage 1 : Perlin noise as a base

I used usual Perlin Noise algorithm, conviently implemented in Unity in Mathf.PerlinNoise() function. Basically, you use it with 2 parameters: x and y, and it returns value in this position. To have a randomly generated map each time you should shift your coordinates randomly.

1

Mathf.PerlinNoise(x * noise.scale + noise.xOffset, y * noise.scale + noise.yOffset)

When the value in the specific point is greater than threshold, then it is ground, otherwise it’s water. The visualization describes this perfectly: peaks are islands, troughs are water.

picture credit: scratchapixel.com

Let’s call this function IsGround(x, y) => bool for later.

Stage 2 : Islands detection

Initially I should mention, that we have a main loop function, that passes through the whole map and tries to detect islands.

1
2
3
4


for (int i = 0; i < worldWidth; i++)
 for (int j = 0; j < worldWidth; j++)
 if (islandIds[i, j] == -1 && IsGround(i, j))
 GenerateIsland(islandIds, i, j);

For the optimization I needed to distinguish islands (I will reveal it a bit further). We have a matrix, where every (x, y) pair (tile coords) is attached to int. It represents the map of detected islands’ indicies. Basically, one function recieves x and y coordinates and checks using matrix, whether there is no island already detected there. If so, it runs GetIslandTiles function to get coords of all tiles that correspond to this island. It works recursively checking all positions around current and stops, when all calls get completed.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


private void GenerateIsland(int[,] islandIds, int i, int j)
{
 List<(int, int)> tiles = new List<(int, int)>();

 // GetIslandTiles writes all island's tiles into tiles list
 GetIslandTiles(islands.Count, tiles, islandIds, i, j);

 // islands is a list of lists of position, so basically the list of islands
 islands.Add(tiles);

 // wait for it
 (float x, float y, int xSize, int ySize, float minX, float minY) = CalculateTextureRect(tiles);
 GenerateIslandSprite(GenerateIslandTexture(tiles, xSize, ySize, minX, minY), x, y);
}

With this working I have access to manipulate each island separately. For example, I set up a filter to remove too small islands to achieve more natural look and better playing experience by checking tiles. Count value is greater than threshold.

Stage 3 : Texture generation

On the first attempt I instantiated all tiles, which are ground and got the final visual of floating islands. However, this process lasted for a few minutes and the performance was unplayably bad. The main problem was not the amount of triangles but the amount of batches. There were too many objects in the scene, so processor sends tons of requests to videocard and it takes very long time.

The first obvious solution was to enable static batching in the game. But these objects have been generated in runtime, so there was no way to apply static batching on them, but dynamic. However, dynamic batching does its work not so well with that count of objects and I was not happy with that.

This is why I decided to extend my system not just to instantiate tiles but to add thier sprites to island’s texture. This reduces the overall count of objects hundred times which provides perfect performance even for a huge map.

This is the algorithm of creating island’s texture: Create a function AddImage2Texture that adds sprite to a certain local position with alpha (if you have isometric map, you have to use alpha). The issue is that Texture2D.SetPixels() do not add sprites, but override them. So it makes it impossible to add images with alpha channel native way. This function is designed to actually add images to the texture. Basically, it runs through the sprite you want to add and if it detects transparent pixel, then it replaces it with the correspond pixel on the texture on the same global textures. So it takes the pixel from underneath it and puts right into current sprite. With this magic done it overrides target texture spot with the new one.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


// colors is basically the texture you add to tex (basic texture of island)
private void AddImage2Texture(Texture2D tex, Color[] colors, Vector2Int imagePosition)
{
 // Array of all tex pixels
 Color[] _colors = new Color[colors.Length];

 // go through all pixels
 for (int i = 0; i < colors.Length; i++)
 {
 // If pixel is transparent
 if (Mathf.Approximately(colors[i].a, 0))
 {
 // Here we calculate position of current pixel on the tex. This pixel is placed right under current one.
 int x = imagePosition.x + i % tileSize.x;
 int y = imagePosition.y + i / tileSize.x;

 _colors[i] = tex.GetPixel(x, y);
 }
 else
 _colors[i] = colors[i];
 }
 // At this stage _colors does not have any transparent pixels and we can hardly rewrite this set of pixel on our texture.
 tex.SetPixels(imagePosition.x, imagePosition.y, tileSize.x, tileSize.y, _colors);
}

We go through all tiles’ positions and apply sprites into the texture using AddImage2Texture function.

If you have isometric geometry, then you need also to write function to convert matrix position to isometric position like this:

1
2
3
4
5


// Takes int matrix position and returns appropriate isometric position
public static Vector2 ConvertPosition(int x, int y)
{
 return new Vector2(x, y + x / 2f);
}

Combining all together

In this snipped of code from Stage 2 I mentioned CalculateTextureRect and GenerateIslandSprite functions. Let’s have a look on those.

1
2
3
4
5
6


islands.Add(tiles);

 // wait for it
 (float x, float y, int xSize, int ySize, float minX, float minY) = CalculateTextureRect(tiles);
 GenerateIslandSprite(GenerateIslandTexture(tiles, xSize, ySize, minX, minY), x, y);
}

CalculateTextureRect

This function calculates bounds and position of a texture. It inputs a list of (int, int) pairs, which are tiles’ positions on an island. Firstly we define minX and maxX values, which are basically the boundaries of texture by X axis. This is how it works:

1

float minX = tiles.Min(pos => ConvertPosition(pos.Item1, pos.Item2).x);

And so on for other 3 parameters (maxX, minY, maxY). Then we use them to calculate width and height of texture and also coordinates x and y.

GenerateIslandSprite

This is a very basic function that instantiates a gameobject and applies the input texture to it through SpriteRenderer

Stage 4 : Extensions

Applying island size threshold

I have access to manipulate each island separately. For example, I set up a filter to remove too small islands to achieve more natural look and better playing experience by checking tiles. Count value is greater than threshold. *Stage 2

tiles.Count field provides information about area of an island.

1

if (tiles.Count <= threscholdIslandSize) return;

Creating light outline for islands

One can use perlin noise to detect whether the certain position on the map is shallow water and make these spots lighter to achieve realistic water appearance.

Procedural generation

This algorithm can be adapted to support procedural world generation. Set up generating islands in a certain chunk but instead of cutting off excess parts that are out of world’s border let them spawn entirely for better visual and preventing algorithm from glitches of generating same islands for several times unnecessary.

Some statistics

I ran my generator with different settings on my laptop and put results in the table:

№	world width	world area	time(s)	GC alloc (MB)
1	$1*10^2$	$1.0*10^4$	1.285	46.9
2	$1*10^2$	$1.0*10^4$	1.285	46.9
3	$2*10^2$	$4.0*10^4$	2.230	238.6
4	$2*10^2$	$4.0*10^4$	2.144	238.6
5	$3*10^2$	$9.0*10^4$	4.498	522.2
6	$3*10^2$	$9.0*10^4$	4.562	522.2
7	$4*10^2$	$1.6*10^5$	9.645	983.0
8	$4*10^2$	$1.6*10^5$	9.261	983.0
9	$5*10^2$	$2.5*10^5$	14.191	1495.0
10	$5*10^2$	$2.5*10^5$	13.879	1495.0
11	$1*10^3$	$1.0*10^6$	56.295	2160.6
12	$1*10^3$	$1.0*10^6$	55.526	2160.6

Each test was repeated twice for better accuracy. With the noise scale parameter equals to 0.04 and noise threshold to 0.65 ground density is 13.667%.

This statistics was gathered with unity profiler by wrapping generation code with UnityEngine.Profiling.Profiler.BeginSample() and UnityEngine.Profiling.Profiler.EndSample()

My hardware: RAM: 16 GB Processor: AMD Ryzen 5 3550H x64 OS: Windows 10 Home 64-bit

Screenshots

Credits

https://www.scratchapixel.com/lessons/procedural-generation-virtual-worlds/perlin-noise-part-2/perlin-noise-terrain-mesh

About project

I am developing tower-defence game about resource collection and processing automatization and defence management. Player needs to build up his base entirely on islands to gather resources and fight out enemies. It seems quite similar to Mindustry.

C# Boost

Wed, 04 Nov 2020 00:00:00 +0000

Disclaimer

My first ever project in C# with (some) documentation and (some) SOLID. The code is funny, my English is relaxed, my confidence high; still, it was precious. It was back in 2020 when I was switching from Python to C# with some assistance, which really helped me push through the initial phase rather quickly. [2026-04-09]

Github repo

Documentation

If You are c# coder and wanna work more effective - you may use my library.

I do and I will upgrade it, so you can use the latest version with fixed bugs/added new features.

Contributing is the good help and motivation for me to make your code more simpless and readable.

What can this lib do?

This lib can simplifie working with collections like list I called Liars & random numbers, collections generators, etc.. More details below.

Examples

Class Liar

Collection, that works really like list, but has more functionality

Insert & remove collections/items, sort, pop, replace and a lot of other funcs.

Class Range

Collection generator

Generates number-filled Liar with some settings. Useful thing)

Class Randomer

Random nums generator

Generates few (or probably one) random numbers. It also can choose item, mix collection and other things, that you missed in default Random)

Class Number

Holds value, that can be anyone number type. It contains int, float, decimal and so on types.

Really useful. It is used in almost whole of library functions.

Static Class Num

Adding some new functions for Number. For example - numsAfterPoint, numsBeforePoint, Pow, Root and other.

Static Class Round

Adding new rounding functions.

Class Set

Holds liar, that has only unique items. Has some functions from liar.

Range in details

The most simple example:

1
2


Liar<Number> myRange = new Range(0, 10);
Console.WriteLine(myRange);

1
2


Range myRange = new Range(0, 10);
Console.WriteLine(myRange);

The different is Liar has functions, that does not have Range. If you have Range obj you can get next/prev item etc.; working with liar gives some other features. So, it is your choose, what whould you use in here.

Example with end < start and step < 0.

1
2
3


Liar<Number> myRange = new Range(15, -5, -2, true, false);
//It whould create reversed Range
Console.WriteLine(myRange);

You also may use your func to change value on the each range iteration:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


Number CurrentValue = 1;
//This var we are changing at the each range iteration

Range RangeObject = new Range(new ToRound(true, 1), 0, 10, 1,
false, false, valueStruct: new FuncANDArgs(SomeFunc));
//Here we are creating one Range object
print(RangeObject);

//FuncANDArgs is a struct in Utils that contains func, args(if you need) 
//and bool var Firstly(if true then func workes before changing value; else after)

dynamic SomeFunc(dynamic args)
{
 CurrentValue *= 2;
 return CurrentValue;
}

Result:

2 4 8 16 32 64 128 256 512

But here range starts from 2 - this is because of Firstly (writed before) is true (default value)

If we whould change Firstly to false this whould be fixed:

1 2 4 8 16 32 64 128 256

If you didn`t understand:

1

valueStruct : new FuncANDArgs(SomeFunc, false)) <- right line :D

You also may create function returns random number for valueStruct:

1
2
3
4
5


int SomeFunc(object[] args)
{
 Randomer r = new Randomer();
 return r.Rand(1, 10); //start, end, step=1
}

Using this func make your Range object filled by random nums

There are some usefull operators:

++; Appends next item

–; Removes last item

+, * Appending collection/item, mults range n times

and so on

Arguments type is Number

PS: I`m sorry, that name of Range class is familiar to System.Range

Randomer in depth

Let`s start!

For the start you should create one Randomer`s object:

1

Randomer r = new Randomer();

You can put start & end values as args when you create object:

1

Randomer r = new Randomer(0, 10, 3); // -> third argument is step. Now you will get random nums that multiplies 3.

Yeah, there is a fourth arg, that means count. Count default value = 1, so you`ll get one rnd number.

1

Randomer r = new Randomer(0, 10, 3, 4); // -> now you`ll get four rnd numbers.

All methods, those names have prefix “Fast” are static.

Rand()

Next step - is creating nums, because we haven`t do it yet.

1

Liar<Number> number = r.Rand(0.001m, 10.5, 4.01f, 7); //Creating some numbers

As you can see, this function can generate random numbers use input arguments

of all number-types (int, decimal, float, short, etc.)

If you need to create nums in loop, you may write your new params in Rand func instead of change r`s fields in each iteration, you should:

1
2
3
4
5
6


for (int _ = 0; _ < 3; _++)
{
 //Some code..
 Number number = r.RandOne(0, 10, 2, 4);
 //Some code..
}

CollectionRandMix()

If you need to mix you collection - use this func!

1
2
3
4


Randomer r = new Randomer();
Liar<Number> something = new Range(0, 6, 1);
something = r.RandMix(something);
Console.WriteLine(something);

Here you`ll get you Liar mixed. It is so usefull))

CollectionRandChoose()

Use this to get random item from your collection.

1
2
3
4
5


Randomer r = new Randomer();
Liar<Number> something = new Range(0, 6, 1);
int count = 4;
Liar<Number> items = r.RandChoose(something, count);
Console.WriteLine(items);

Here you are!

Liar

Start!

Firstly, we should create new object:

1

Liar<int> myLiar = new Liar<int>();

If you wanna put some items into Liar by easy way:

1

Liar<int> myLiar = new Liar<int>() { 1, 2, 3 }; //Just put your items here, like you do it with List

or create the same one by another way:

1

Liar<int> myLiar = new Liar<int>( 1, 2, 3 ); //Result is same as previously

You also can remove, append, pop, get items, sort by lots of rules, concatenate and multiply, reverse, replace items and other functions. Try it!

Appending & Inserting

The same thing to Lists.

.Append(item) - appends item to end;

.Add(item) - the same one to Append;

.AppendCollection(collection) - appends collection to end;

.Insert(item, index) - inserts item to index;

.InsertCollection(collection, index) - inserts collection to index;

.Prepend(item) - adds item to start.

1
2


Liar<Number> a = new Liar<Number>();
a.Append(2);

1

 >>> 2

1
2


Liar<Number> a = new Liar<Number>();
a.Insert(2, 3); //if collection is empty - index=0

1

 >>> 2

1
2
3


Liar<Number> a = new Liar<Number>() {1,2,3};
Liar<Number> b = new Liar<Number>() {6,5,3};
a.InsertCollection(b, 1);

1

 >>> 1 6 5 3 2 3

Removing

.Remove(item) - removes first item;

.RemoveAt(index) - removes liar[index];

.RemoveAt(index, count) - removes all from index count times;

.RemoveRange(start, end, step) - removes range;

.RemoveAtIndecies(indecies) - removes items at all indecies;

.RemoveCollection(collection) - removes all item that liar collection have;

.RemoveAll(item) - removes all items;

.RemoveAll() - clears;

.RemoveAll(function) - removes all items function(item) == true;

.RemoveFirst(item) - the same to regular remove;

.RemoveFirst() - removes first;

.RemoveFirst(function) - removes first item function(item) == true;

.RemoveLast(item) - removes last item;

.RemoveLast() - removes last;

.RemoveLast(function) - removes last item function(item) == true;

1
2


Liar<Number> a = new Liar<Number>() {1,2,3};
a.Remove(2);

1

 >>> 1, 3

1
2


Liar<Number> a = new Liar<Number>() {1,2,3};
a.RemoveAt(0);

1

 >>> 2, 3

1
2


Liar<Number> a = new Range(0, 5, 1, true, true);
a.RemoveAtIndecies(0, 2);

1

 >>> 1, 3, 4, 5

Replacing

.ReplaceAll(oldValue, newValue) - replaces all items equal oldValue for newValue;

.ReplaceSome(oldValue, newValue, count) - replaces count entries of oldValue for newValue;

.ReplaceSome(oldValue, newValue, count, start) - replaces all items equal oldValue for newValue from start to start + count;

.ReplaceFirst(oldValue, newValue) - replaces first item equals oldValue for newValue;

.ReplaceLast(oldValue, newValue) - replaces last item equals oldValue for newValue;

.ReplaceInRange(oldValue, newValue, start, end) - replaces all items equal oldValue for newValue in range;

.ReplaceAllCollection(oldValues, newValues) - replaces all entries of items from oldValues for newValues;

.ReplaceSomeCollection(oldValues, newValues, count) - replaces count entries of items from oldValues for newValues;

.ReplaceSomeCollection(oldValues, newValues, start, end) - replaces all entries of all items from oldValues for newValues in range;

.ReplaceFirstCollection(oldValues, newValues) - replaces first entry of all items from oldValues for newValues;

.ReplaceLastCollection(oldValues, newValues) - replaces last entry of all items from oldValues for newValues;

1
2


Liar<Number> SomeCol = new Liar<Number>() { 0, 1, 6, 2, 7};
SomeCol = SomeCol.ReplaceFirst(2, 9);

1

 >>> 0, 1, 6, 9, 7

1
2


Liar<Number> SomeCol = new Liar<Number>() { 2, 1, 6, 2, 7, 2, 4, 2};
SomeCol = SomeCol.ReplaceAll(2, 9);

1

 >>> 9 1 6 9 7 9 4 9

Sorting functions!

Library has the one and very-very effective algorithm - is called “Fast sorting” Yeah, it`s pretty obvious that this function is fast)) This functionality is owned by class Sorter.

1
2
3


Liar<Number> myLiar = new Range(0, 10, -2);
print(myLiar);
print(Sorter.QuickSort(myLiar));

Result:

8 6 4 2 0
0 2 4 6 8

First line - is raw liar; Second - sorted

String sorting!

1
2


Liar<string> l = new Liar<string>() {"Awake", "Honey", "Oak", "Bike", "Wizard", "USA"};
Console.WriteLine(Sorter.QuickSort(l, SortingMode.STRINGcharGREATER));

SortingMode modes:

*GREATER, greater nums

*LESS, less nums

*EQALS, nothing changes

*RANDOM, random mixing

*STRINGlenGREATER, greater length

*STRINGlenLESS, less length

*STRINGcharGREATER, greater char in string num

*STRINGcharLESS, less char int string num

*CHARGREATER, greater char num by right

*CHARLESS less char num by right

project started at 24.08.2020