First create a .desktop file on your desktop.

nano ~/Desktop/Godot.desktop

Now add the following code, and adjust the location to match your application and icon location. Here I’ve downloaded and copied Godot to Applications in my home directory.

[Desktop Entry]
Type=Application
Name=Godot
Exec=/home/nope/Applications/Godot_v4.4-stable_mono_linux.x86_64
Icon=/home/nope/Applications/GodotIcon.png
Terminal=false

After saving the file, we need to make it executable, to be able to run the application by clicking the icon.

chmod +x ~/Desktop/Godot.desktop

Before you can just start the application by clicking it, you need to right-click the icon and select “Allow Launching”.

That’s it! You can now run the application by simply clicking the icon.

Optional

If you want to add the application to the application menu. You just have to copy the .desktop file to ~/.local/share/applications/ and the application will show up in the application menu.

Here is how to do it;
First create the different config files, one for each folder.

.gitconfig-work

[user]
  email = workEmail@work.com
  name = workName
[core]
  autocrlf = input
[credential]
  helper = store

.gitconfig-private

[user]
  email = privateEmail@private.com
  name = privateName
[core]
  autocrlf = input
[credential]
  helper = store

And now the .gitconfig

[includeIf "gitdir:~/workFolder/"]
path = ~/.gitconfig-work

[includeIf "gitdir:~/privateFolder/"]
path = ~/.gitconfig-private

When you now push to repositories located in privateFolder the name privateName will be used, and for the folder workFolder the name workName is used.

Have you ever wanted to just host your repositories at home instead of handing over everything to some lesser trustworthy third-party site? Then this might be a simple solution for you.

Setup

To create the local hosted git repository.

>cd location_for_the_repository
>git init --bare new_local_hosted_repo.git

This will create a folder ending in .git
Now to use it, navigate to where you want to checkout your working directory

>cd working_directory

and clone the newly created repository

>git clone full_path_to_new_local_hosted_repo.git

The workspace is now ready to use, and you can do all the same things you would normally do, using GitHub, Bitbucket or any other online repository.

A Full example:

>mkdir ~/repositories
>cd ~/repositories
>git init --bare best_game_ever.git
>mkdir ~/workDirectory
>cd ~/workDirectory
>git clone ~/repositories/best_game_ever.git
>cd best_game_ever
>touch ./note.txt
>git add *
>git commit -m "initial commit"
>git push

Note: Remember to backup ~/repositories

L-systems were introduced and developed by Aristid Lindenmayer back in 1968 and are often used to produce fractals or images of flowers, as the repeating nature of some flowers is very easy to reproduce using L-systems. L-systems consist of four parts: variables, constants, Axiom, and rules. The rules describe how the axiom, or start expression, evolves from iteration to iteration.

Let’s look at a classical example:

• Variables: L
• Constants: +, −
• Axiom: L
• Rules: L => L-L++L-L

How the different symbols are interpreted is entirely up to us, but in this example, we define:

• L to mean “draw line forward”
• + to mean “turn left”
• − to mean “turn right”

So the algorithm is a simple search and replace. We go through the axiom or start string L and replace it according to the rule, resulting in the following strings:

• Iteration 1: L => L-L++L-L
• Iteration 2: L-L++L-L => L-L++L-L-L-L++L-L++L-L++L-L-L-L++L-L
• Iteration 3: L-L++L-L-L-L++L-L++L-L++L-L-L-L++L-L => L-L++L-L-L-L++L-L++L-L++L-L-L-L …

and we can keep going for as many iterations as we like, but as we can already see, the resulting string grows very raptly because of the “long” rule for L. If the rule for L was simpler, the resulting string of cause wouldn’t grow as fast.

Repeatedly applying the rules increases structure and complexity.

But enough theory; If you want more information, you can read an in-depth explanation of L-systems on Wikipedia.

Implementing the L-system.

We’ll be use strings for variables, constants, and axiom, a StringBuilder for building up the result, and a simple Map<string, string> for the rule(s), defining the string to search for and what to replace it with.

First we define the RuleSet:

@Serializable
data class RuleSet(val rules: Map<String, String>, val axiom: String)

As simple as can be, simple data class containing the axiom and the Map containing the rules.
We need the annotation @Serializable as we will be reading the rules from a JSON file.

{
  "rules": {
    "L": "L-L++L-L"
  },
  "axiom": "L"
}

This is the simple rule for creating the image displayed above.

The simple constructor for the LSystem class is only taking a RuleSet as parameter:

class LSystem(private val ruleSet: RuleSet)

The generate function takes in the number of iterations to run and calls the generateExpression that number of time. It also times how long each generation takes in nanoseconds.

fun generate(iterations: Int) {
    expression.append(ruleSet.axiom)
    
    var startTime: Long
    var endTime: Long
    
    for (i in 0 until iterations) {
        startTime = System.nanoTime()
        expression = generateExpression(expression)
    
        endTime = System.nanoTime()
        println("Time to generate iteration ${i + 1}${endTime-startTime}ns - With a size of ${expression.length}")
    }
}

The generateExpression function is the heart of the L-System. It goes through the current expression character by character and tries to match up the rules with the upcoming characters using the matchesPattern helper function. When a match is found, the resulting string from the rule is appended to the new expression. If no match is found, the current character is appended to the new expression. This approach avoids the need for rules that don’t replace anything, such as “-” => “-“.

private fun generateExpression(expression: StringBuilder) : StringBuilder {
    val newExpression = StringBuilder()
    
    var position = 0
    while (position < expression.length) {
        var matched = false
    
        // Check each pattern in order
        for (pattern in ruleSet.rules) {
            if (position + pattern.key.length <= expression.length && // check we are not matching outside the expression
                matchesPattern(this.expression, position, pattern.key)
            ) {
                matched = true
                position += pattern.key.length // Move the position forward after matching
                newExpression.append(ruleSet.rules[pattern.key])
                break
            }
        }
    
        if (!matched) {
            newExpression.append(expression[position])
            position++ // Move to the next position if no pattern matched
        }
    }
    
    return newExpression
}

The helper function matchesPattern goes through the characters in the pattern and tries to match them with the next characters in the input StringBuilder. This is a greedy approach, so the order of the rules matters. For instance, if we have the two rules “-” => “L” and “–” => “L” in that order, the second rule will never be applied because the first rule always matches first. Therefore, place the longer rules first.

We could pre-sort the rules, but for this introduction, we just have to keep the order in mind.

  private fun matchesPattern(input: StringBuilder, position: Int, pattern: String): Boolean {
    for (index in pattern.indices) {
        if (input[position + index] != pattern[index]) {
            return false // Return false if any character doesn't match
        }
    }
    
    return true // Return true if all characters match
}

Implementing the Visualizer

So now we have a long string of characters, but we need to interpret in some way. This is where the visualizer comes in.
We started by defining the variables and constants –, +, and L, so now we just have to draw from the expression.

The Visualizer constructor takes a few parameters:

• expression, the expression to be interpreted
• imageSize, the size for the output image
• padding, the padding around the figure to the edge of the image, in pixels
• filename, the filename for the output file.

class Visualizer(
    private val expression: StringBuilder,
    private val imageSize: Vector2,
    private var padding: Float,
    private var filename: String
) 

Let’s start with the rules and the drawing function doTurtleAction. But for that to make sense, we’ll also have to look at the SystemState data class.

data class SystemState(
    var position: Vector2,
    var angle: Float,
    var length: Float,
)

fun doTurtleAction(c: Char, state: SystemState, canvas: Canvas? = null, draw : Boolean = true) {
    when (c) {
        'L' -> drawLine(state, canvas, aPen, draw)
        '+' -> state.angle += 45
        '-' -> state.angle -= 45
    }
}

The SystemState class keeps track of the current position of the pen drawing the figure, the current angle in degrees, and the length. This can be extended to keep a stack of positions that can be pushed and popped so that when drawing, it can store a position, draw something, and return to that position. However, this isn’t implemented in this simple version.

In doTurtleAction, using Kotlin’s when function makes interpreting the character very straightforward. Here, we define what we want the different variables and constants to do. We use 45 degrees for + and – because this will create a nice Koch fractal, but you can set it to whatever you like. L draws a line based on the length and angle in state.

I added some extra steps in the Visualizer to help always output a nice image of the whole figure. That is, I go through the entire algorithm without drawing anything; I only log the minimum and maximum positions. This allows me to scale the lines to draw and set the starting position so the figure is centered and fills the given image size, excluding the padding.

Calculating the area of the figure with the line at size 1 is done using the calcArea function.

private fun calcArea(): Rectangle {
    val state = SystemState(
        angle = 0f,
        length = 1f,
        position = Vector2(0f, 0f)
    ) hosted 
    
    expression.toString().forEach { c ->
        doTurtleAction(c, state, null,false)
        updateAreaData(state)
    }
    
    val x = floor(minXPosition)
    val y = floor(minYPosition)
    val w = ceil(maxXPosition) - x
    val h = ceil(maxYPosition) - y
    return Rectangle(x.toInt(), y.toInt(), w.toInt(), h.toInt())
}

When outputting the image, we start by getting the area and performing some calculations to get the scale and the starting point to use.

private fun outputAsImage(maxImageSize: Vector2, filename: String) {
    val area = calcArea()
     
    val xScale = (maxImageSize.x - padding) / area.width
    val yScale = (maxImageSize.y - padding) / area.height
    val scale = if (xScale < yScale) xScale else yScale
    
    val state = SystemState(
        angle = 0f,
        length = scale,
        posi hosted tion = Vector2(minXPosition * (-scale) + (padding / 2), minYPosition * (-scale) + (padding / 2))
    )

Now we setup the canvas to draw on. Here we use the Kotlin wrapper for the Skia 2d graphics library called skiko.

    val surface = Surface.makeRaster(ImageInfo.makeN32(maxImageSize.x.toInt(), maxImageSize.y.toInt(), ColorAlphaType.OPAQUE))
    
    // Get the canvas from the surface
    val canvas = surface.canvas
    // Clear the canvas with a white background
    canvas.clear(Color.TRANSPARENT)

Note: The Kotlin wrapper for Skia doesn’t use the same naming for classes and functions, which makes it challenging to use the documentation for Skia. After a lot of searching, I got it working, but without a deeper understanding of why, so I’m not sure if it’s the right way of using it. But it works.

Now we draw the figure and output the image to a file.

    expression.toString().forEach { c -> doTurtleAction(c, state, canvas) }
    
    // Get the snapshot of the surface
    val image = surface.makeImageSnapshot()
    
    // Encode the image as a PNG
    val data = image.encodeToData(EncodedImageFormat.PNG, 100)
    
    // Save the PNG to a file
    File("$filename.png").writeBytes(data!!.bytes)
}

That’s it!
I’ve added the full project code here, for free download.

Thoughts:

However, nothing says we must use repetitive rules; we can do whatever we want. We could alternate between differenthosted rules, shift rules when a specific pattern is seen, reverse parts based on other triggers, or use any approach that could yield an interesting result. I like to add randomness to the constants, so instead of turning exactly 90 degrees, we turn 90 degrees plus or minus some small random value to introduce variation. Create different weighted rules, allowing multiple rules for the same pattern with different probabilities! “Barney Codes” has already implemented this, as seen in YouTube video.

The game is a simple item fetch game, with a few small jokes in there. It is heavily inspired by the amazing over polisher of all, the one, the only Pixel Prophecy! Also know as Phil Strahl.
He really likes his coffee, so the game needed coffee, and then he has a thing with unicorns, so again the game had to have at least one unicorn.
The gameplay is simple; the unicorn tells you what it want’s to eat, and you fetch it, and the unicorn poops a delicious, huge, coffee bean. The coffee beans can be taken to the coffee machine and made into a hot cup of coffee, giving you a 10% boost in the amount of coffee you contain. At 100% you have won the game. At 0% you have lost.
There are two other ways to loos the game, but that is for you to find out by playing it.
I hope you will spend a few minutes playing, and hopefully enjoy it. Thanks.

– H

Links to the Ludum Dare page, and the HTML5 version.

@INCD021 We wrote a poem about your game Don't Stub Your Big Toe! http://t.co/9NPdGVe8Q1

— Poems About Games (@PoemsAboutGames) October 20, 2014

The #30daydev have already given me so much, and I’m only halfway there. I’ll keep learning..

Now, go make games!

– Henning

It’s an old turn based racing game we used to play on paper when I was a kid.
You have to select one of 8 possible moves, the next move will start by moving the same amount as you did last move.

So if you moved 1 step forward as your first move, the next 8 possible moves will be around 1 step forward from your current position.

The hard part is trying to gain maximum speed and to remember to brake in do time. 70% of the time you gain to much speed and won’t be able to turn in time. BOOM!

Again it took waaay to long to develop. This time caused by a small oversight on my part that took hours to find I missed some coliders/layer in my raycast

Now it’s time for ZZzzzzzzzz………

Now, go make games!

– Henning

As the name sugests you have you yell at the game, to move. The louder you yell the further the player objects move apart.

I added a sencitivity slider to adjust the needed sound volumen to move, so you don’t really have to yell at the game.

The game only works if you allow it to use the default microphone of your computer, so if you don’t want to, then sorry you won’t be able to play.

Have fun yelling at gamejolt

Now, go make games!
– Henning

I had to think of something? Sleeping until 7 and didn’t help, food and a shower.. Now an idea started to form. The void ship from the Dr. Who series and the hunt for the Maquis from Star Trek, void ship = between worlds,  hunt for the Maquis = turbulent and violent space.. hmmm. To the blackboard, and draw 3D, draw 2.5D, ok then 2d.. Couldn’t figure out how I wanted the game to look, as I would like to do it in 2d (haven’t done 3d since unity came out with their 2d support), I just couldn’t squash the 3D into 2D.

Remembering that I only had 48 hours and 5 was gone sleeping, eating and showering already. I had to keep it simple. So why not having two universes, one on top of the screen and one on the bottom, and having to fight invaders from the other universe. So I set out to do so.

What I have ended up with is almost that. Only change is that the enemy ships are wormhole generators that you have to shoot down before they can open a wormhole, and there by destroying the other universe (I have allowed myself some freedoms as I do not know how wormhole from a universe with other lawn of nature would impact our universe or it’s even possible).

You can play the game Join Us! online, or download the PC version here.

Learned a lot, especially not to optimize as much as I do. I have done some things where I thought, this will be slow, but it’s micro seconds, so doesn’t matter. Ended up with at most 10 draw calls which is nothing. Now I have uploaded the PC version and the web version to Ludum Dare I don’t really wan’t to work on it any more, I’m mentally tired and just want to relax and not think about “Join Us!” anymore,  for now…

It’s been fun and amazing to see how much you can do, when you don’t focus on having to deliver something amazing and super polished, but just a game someone would enjoy So hope you will play it, enjoy it, and rate it on Ludum Dare.

Now, go make games

– Henning