Devops on Dag's home

How to move from GitHub to Codeberg

dag7+ifyourenotallmpleaseremovethis@protonmail.com (Dag) — Tue, 12 May 2026 16:45:00 +0200

Migrate from Github to Codeberg

Are you tired of GitHub social tab? What about issues tab being “removed” in favor of AI?

There’s AI everywhere nowadays, but Github was one of the places that were left untouched.

Not anymore.

[!INFO] FYI Some code has been written and tested with the help of an AI

Why

Codeberg is not controlled by a commercial entity, but by its non-profit association based in Berlin, Germany
- this means that every change is led by the community
- no forced AI
- no stupid UI/UX changes “because they say so”
Codeberg servers are based in Berlin, in EU, unlike Github servers
Codeberg run Forgejo that is open source
You don’t want to use a popular platform, whatever the reason

How

The general idea is: use Codeberg as main and GIthub as a mirror. Or viceversa.

Migrating from GitHub to Codeberg is not a straightforward process.

The estimated time for the entire procedure is about 45min.

Preliminary steps

Create a Github Token with “all” permissions (see here)
Create a Codeberg with “all” permissions (see here)
Save them somewhere in your computer. You’ll need both of them.

Let’s export these variables for the current shell:

export CODEBERG_USERNAME="codeberg-username"
export CODEBERG_TOKEN="codeberg-token"
export GITHUB_TOKEN="gh-token"
export GITHUB_USERNAME="github-username"

We’ll need them later. Make sure by giving echo $CODEBERG_TOKEN it prints <codeberg-token>.

[!NOTE] Security Issues It’s not a safe idea issuing these commands, due to the history shell command. If you are an advanced user, and feel that ’this is bad’, find a proper safer way. One idea is to save it in .bashrc and reload the bash, and remove everything when it’s over.

Github: spring cleaning regardless of the season

In your public repos: is there any fork that you don’t use? If yes, delete it.

In your private ones: is there any project that you started years ago and never touched anymore because you were too scary or full of work? It is a good time to delete them.

Is your public repo a private one? Make sure to “publish” it and viceversa.

Unless you’re ready to deal with Forgejo and so on, the repos that has workflows or something more complicated, should remains on Github.

(optional) Download all your Github repos in local

You never know.

Save this script in your home and launch it with ./github_to_local.sh:

#!/usr/bin/env bash

set -euo pipefail

DEST="$HOME/github-backup"
mkdir -p "$DEST"

cd "$DEST"

page=1

while :; do
 repos=$(curl -s \
 -H "Authorization: Bearer $GITHUB_TOKEN" \
 -H "Accept: application/vnd.github+json" \
 "https://api.github.com/user/repos?per_page=100&page=$page&type=owner" \
 | grep -o '"clone_url": *"[^"]*"' \
 | cut -d '"' -f4)

 if [ -z "$repos" ]; then
 break
 fi

 for repo in $repos; do
 repo_name=$(basename "$repo" .git)

 if [ -d "$repo_name" ]; then
 echo "Skipping existing repo: $repo_name"
 continue
 fi

 echo "Cloning $repo"

 git clone "https://$GITHUB_TOKEN@${repo#https://}"
 done

 page=$((page + 1))
done

Move from Github to Codeberg

This excellent script from LionyxML is pretty customizable and allow us to move from one place to another the repos.

Make sure to either export the variables as explained at the beginning of the guide, or fill the variables at the beginning with your data.

wget https://raw.githubusercontent.com/LionyxML/migrate-github-to-codeberg/refs/heads/main/migrate_github_to_codeberg.sh

Everything is written in the file, but here’s a small portion, that’s how I set up:

# !!!!! 
# Since you have exported your usernames and tokens before, there is no need to redeclare them here. If needed, uncomment them.
# !!!!!

# GitHub username and personal access token
# GITHUB_USERNAME="YourGitHubUsername"
# GITHUB_TOKEN="YourGitHubToken"

# Codeberg username and personal access token
# CODEBERG_USERNAME="YourCodebergUsername"
# CODEBERG_TOKEN="YourCodebergToken"

# REPOSITORIES array with repository names you want to migrate, one per row with commas
# blank = ALL repositories
REPOSITORIES=()

# OWNERS array with specific usernames whose repositories you want to migrate, one per row
# blank = ALL repositories
OWNERS=(
	"$GITHUB_USERNAME"
)

Since we want to migrate everything… let’s leave everything as it is, but I’m not interested in the code I’ve created in the organizations.

Therefore, I’ll write my name in “owners” array.

Save the script in your home directory, fill with your information, make it executable and launch it.

Wait a while and… boom, your Codeberg account is now populated.

[!Danger] Warning Make sure to change visibility to “private” those repos that you will manage through Github, or even better, delete them. This will help Codeberg in being a free, cleaner space for everybody. Furthermore, you’ll avoid code duplication.

Make also sure to adhere to their principles.

Following and followers

We need to perform two actions:

Check if a user exists
Fetch the list of following and followers Github users in our profile, and try to see if there’s a match on Codeberg

Check if a user exists

In a file named check_codeberg.sh let’s write:

#!/usr/bin/env bash 
 
for user in "$@"; do 
   status=$(curl -s -o /dev/null -w "%{http_code}" \  
       "https://codeberg.org/api/v1/users/$user") 
 
   if [ "$status" = "200" ]; then 
       echo "$user exists" 
   else 
       echo "$user does not exist" 
   fi 
done

Make it executable:

chmod +x check_codeberg.sh

And run it with an username:

./check_codeberg.sh torvalds
torvalds exists

Fetch the list of following and followers Github users

Let’s move to the second action.

Let’s retrieve following people of our own profile with these piece of code:

page=1; while body=$(curl -s -H "Authorization: Bearer $GITHUB_TOKEN" "https://api.github.com/users/$GITHUB_USERNAME/following?per_page=100&page=$page"); do 
[[ $(jq 'length' <<< "$body") -eq 0 ]] && break 
jq -r '.[].login' <<< "$body" >> following.txt 
((page++))
done

And followers:

page=1; while body=$(curl -s -H "Authorization: Bearer $GITHUB_TOKEN" "https://api.github.com/users/$GITHUB_USERNAME/followers?per_page=100&page=$page"); do 
[[ $(jq 'length' <<< "$body") -eq 0 ]] && break 
jq -r '.[].login' <<< "$body" >> followers.txt 
((page++)) 
done

We cannot merge both instructions because we may have more followers than following and viceversa.

All together now

It’s now time to see who’s on codeberg.

Let’s merge following and followers list into one file:

cat following.txt followers.txt | sort | uniq >> people.txt

And now, let’s find out who’s online:

while read -r user; do 
   curl -s -o /dev/null -w "%{http_code}" \  
   "https://codeberg.org/api/v1/users/$user" | grep -q 200 && echo "$user found! -> https://codeberg.org/$user" 
done < people.txt

[!NOTE] Enhancements This could be further enhanced by calling Codeberg API Keys and blindly following every account. Since sometimes people’s username may be different than the github ones (like me), always check profiles before blindly following everyone

That’s all folks!

Have I been useful? Support my work [on ko-fi](ko-fi.com/dag7, even a small euro could make the difference.

Thanks for reading this.

GitLab Pipeline Tiramisu

dag7+ifyourenotallmpleaseremovethis@protonmail.com (Dag) — Mon, 08 Sep 2025 15:29:03 +0200

GitLab CI/CD Pipeline Tutorial for Beginners

During a DevOps crash course, I’ve been called to teach how to setup a simple GitLab pipeline.

It wasn’t easy: the people who took part in that course, were from very different backgrounds: backend in PHP, frontend, people out of school at their first job employment… despite of this, I’ve talked to them about what a devops does, who is it, and how pipelines are important.

In this article, you are going to learn how to setup a simple toy pipeline, in order to experiment a little bit with GitLab runners.

I don’t care just gimme the recipe and I’ll figure out everything else!!! here it is

How to do it

The first step is to have a GitLab account. You can sign up for a GitLab account here. I personally don’t use that much GitLab, but I will move provided my use cases fits GitLab.

Next, you should create a repository:

fill the blanks as you prefer

and click the blue button “create a project”

Runner, YAML, pipeline… what are you talking about?

Now it’s time to write a small pipeline and set the runner.

Pipeline

A pipeline is a group of steps (named “stages”) that include jobs, what we need to do in each stage.

To understand more this concept, imagine cooking a Tiramisu: you have to first prepare ingredients, then you have to assemble them, there is a cooling part and the final step is service. These all stages.

Jobs can be, in the stage of preparing ingredients: make some coffee, whip cream and sugar…

Stages and jobs together in a file, form a pipeline, that is given to a runner.

Runner

A runner is a server, running Linux, that will take what you wrote in your pipeline and setup all the processes in order to accomplish what you told it.

For example, if we said “dear runner, compile our application (given a Dockerfile) and publish it on GitLab” it will exactly do this thing.

The way to communicate between us and the machine, is using a YAML file.

YAML

A YAML file is a plain text file, with some instructions in there. YAML is a declarative language, meaning that we don’t have to write specific keywords in order to describe or achieve something in particular, rather than we focus more on the grammar of the language to reach our goals.

To learn YAML I strongly suggest this amazing website that will teach you in no time how to write some YAML.

Ok, how do I setup the runner?

Left side of the menu, “build”, “pipelines”

Next, click on the “test template”

We will be in the pipeline editor: this will create a .gitlab-ci.yml file at the end of our edits.

Click “commit changes” at the end and wait for a pipeline running warning at the top of the page.

If you click on the link in blue, you will see something like this:

don’t worry if something doesn’t have a green tick, it will be a matter of time.

If everything goes well, everything’s will be marked in green.

This means that pipeline has succeeded.

I got it, now I want to write a toy pipeline that describes a Tiramisu recipe

Here’s the YAML file to copy paste in the pipeline:

stages:
- prep
- assembly
- cooling
- serving

prepare_cream:
stage: prep
script:
- date +%H%M%S
- echo "I beat the egg yolks with the sugar"
- echo "I add the mascarpone"
- echo "I whip the cream and fold it in"

prepare_coffee:
stage: prep
script:
- date +%H%M%S
- echo "I prepare the coffee with the Moka pot (preferably a large one)"
- echo "I let the coffee cool"

prepare_ladyfingers:
stage: prep
script:
- date +%H%M%S
- echo "I prepare the ladyfingers"

soak_ladyfingers:
stage: assembly
script:
- date +%H%M%S
- echo "I dip the ladyfingers in cold coffee"

layer_layouts:
stage: assembly
script:
- date +%H%M%S
- echo "Arrange the ladyfingers in the pan"
- echo "Spread the mascarpone cream"
- echo "Repeat the layers until the pan is full"
- echo "Drizzle the surface with bitter coffee or chocolate"

chill_tiramisu:
stage: cooling
script:
- date +%H%M%S
- echo "I refrigerate the tiramisu for at least 4 hours"

serve_tiramisu:
stage: serving
script:
- date +%H%M%S
- echo "I get the set of plates"
- echo "I plate the tiramisu"
- echo "I serve it to my guests"
- echo ":)"
- echo "Measure blood sugar"

This is the recipe in Italian:

stages:
- preparazione_ingredienti
- assemblaggio
- raffreddamento
- servizio

prepara_crema:
 stage: preparazione_ingredienti
 script:
 - date +%H%M%S
 - echo "Monto i tuorli con lo zucchero"
 - echo "Aggiungo il mascarpone"
 - echo "Monto la panna e la incorporo"

prepara_caffe:
 stage: preparazione_ingredienti
 script:
 - date +%H%M%S
 - echo "Preparo il caffé con la Moka (meglio se grande)"
 - echo "Lascio raffreddare il caffè"

prepara_savoiardi:
 stage: preparazione_ingredienti
 script:
 - date +%H%M%S
 - echo "Preparo i savoiardi"

inzuppa_savoiardi:
 stage: assemblaggio
 script:
 - date +%H%M%S
 - echo "Inzuppo i savoiardi nel caffè freddo"

metti_strati:
 stage: assemblaggio
 script:
 - date +%H%M%S
 - echo "Disporre i savoiardi nella teglia"
 - echo "Stendere la creama al mascarpone"
 - echo "Ripetere gli strati fino a esaurire lo spazio nella teglia"
 - echo "Spolverare con caffè amaro o cioccolato in superficie"

raffredda_tiramisu:
 stage: raffreddamento
 script:
 - date +%H%M%S
 - echo "Metto il tiramisù in frigo per almeno 4 ore"

servi_tiramisu:
 stage: servizio
 script:
 - date +%H%M%S
 - echo "Prendo il set di piattini"
 - echo "Impiatto il tiramisù "
 - echo "Servo ai miei ospiti"
 - echo ":)"
 - echo "Misurare la glicemia"

Save it into your pipeline editor, commit and…?

Where Tiramisu?

We have cooked a delicious tiramisu and learnt how the pipeline works! 🍰🍫☕️

Ending

Thanks for your attention, I highly suggest to try it out this simple example to get started with GitLab runners and pipelines. This was a toy example, but many other awesome things can be done.

Try this pipeline in your own GitLab project and share your results by sending me an email!

NOTE: the line “date” in script part, is for echoing the date time when the job is executed. This is to figure out if the job execution is done in parallel or in sequence. Figure it out for yourself, which of the two ways.

Django Day

dag7+ifyourenotallmpleaseremovethis@protonmail.com (Dag) — Fri, 04 Oct 2024 14:47:01 +0200

The event

Django Day in Copenaghen is an event dedicated to Django, the Python web framework. It was a one-day event, and I had the chance to attend it as a speaker.

I’ve decided to talk about Chiptune, a genre of music that uses the sound chips of old computers and consoles to create music.

The talk

I’ve presented a small introduction to Chiptune, explaining what it is and how it is made. I’ve also shown some examples of main artists, the demoparties, the Chiptune music, and I’ve explained how to create Chiptune music using a tracker and what’s the difference between a tracker and a DAW.

The slides

If you’re here, you probably would like to download the slides of my talk.

Maybe you’re interested in Chiptune, or maybe you’re interested in the talk I’ve done.

Click here to download the slides.

If you don’t feel up to download the slides, click here to see a youtube video of me in action.

The feedback

The feedback was great. I’ve received some questions about Chiptune after the talk. I talked with some people who knew artists and discovered new people doing music.

I also make music, take a look if you please!

The organizers were happy with my talk, and they’ve asked me if I would have liked to perform a live Chiptune session. I’ve accepted, and I’ve performed a small live session at the end of the event, using my Gameboy.

Dungeon Devlog #5

dag7+ifyourenotallmpleaseremovethis@protonmail.com (Dag) — Mon, 10 Jun 2024 23:47:02 +0200

I am caught up in something else and have been slowing down these days.

The situation has become untenable: I feel the need to write tests and modularize the code further.

Things break and I don’t know why.

Anyway, I manage to create a small inventory by deciding to treat the inventory as a dictionary and inserting an object into it every time it is printed in the overlay.

There’s a problem: exits are added to the inventory, that it is not what we want, but never mind: this is a problem I will fix another time.

I also decide to implement the fact that enemies counter-attack by assigning each monster an attack and a defense and making it so that when they counter-attack and when I attack, according to small mathematical formulas the hp is decreased or not.

To get around the regeneration problem I temporarily decide to make the character recover one hp every time he moves.

I also decide to implement the fact that the character can die: if the hp is less than 0, the game ends. To start a new game, just press the “R” key.

The game is starting to take shape, but I have to fix some bugs and make it more playable, for now I’d like to polish on textures and make the game more enjoyable, so I manage to understand when to use border’s tileset and when not.

Other wishable features are:

handle items in the inventory
fix enemies texture bug
add proper tiles for the border in the map
invent a story
add a boss / boss room

I am very happy with the progress I made, but I have to keep going.

Dungeon Devlog #4

dag7+ifyourenotallmpleaseremovethis@protonmail.com (Dag) — Fri, 07 Jun 2024 22:35:13 +0200

Tonight is the night! I need to implement graphics!

Well, how to do it? Old videogames were made with spritesheets, so I decide to do the same. I downloaded a spritesheet from a free itch.io download link, and I am ready to go…?

But what’s the basic idea? I have to draw the map exactly as I did before, but instead of drawing colored squares, I have to draw textures.

The steps are:

load the spritesheet
while drawing the map, if the tile is a wall then go to the spritesheet and take the 4th square by row and column
1. for example, if the wall is at row 1 and column 1, then the square is at row 0, column 0, wide 16 and high 16
2. if the character is at row 2 and column 1, then the square is at row 161 and column 116, wide 16 and high 16, and so on
3. this is because the spritesheet is 16x16 and every square is 16x16

This is feasible, so I decide to go ahead: I modify the main structure by adding row column and spritesheet where the graphics are saved.

After that, instead of drawing colored squares I decide to draw textures, each 16x16 and… it’s a great idea, everything works, I just have to be careful to change the sprites of the enemies.

Wouldn’t it be nice a minimap in the HUD too? Of course, it may come in handy for me for debugging purposes but also for the player in the future.

I notice that minimap is the same map I normally draw, but with pixels 1x1 instead of tiles. Basically there is no need to rewrite the code, just to make a function that draws a general map.

Since the code is starting to be a mess, I decide to refactor it a bit: dictionary will store each element’s characteristics, like this:

 {
 "enemy": {
 "x": 10,
 "y": 10,
 "hp": 10,
 "attack": 2,
 "walkable": False,
 ...
 },
 ...
 }

Look how it’s beautiful!

Now it’s time to improve the HUD and set health points and attack points to the protagonist and enemies.

I decide to also change the function that inserts stuff into the map: in case of enemies/living people, it also inserts additional parameters such as residual hp or collected tool, so that I can manage enemies’ items and death as well.

I finally decide to implement a simple level up (experience) and level up mechanism, by using some math functions and randomness.

Dungeon Devlog #3

dag7+ifyourenotallmpleaseremovethis@protonmail.com (Dag) — Thu, 06 Jun 2024 23:46:23 +0200

Good morning Night City -Cyberpunk 2077

My morning is not a morning, but an evening, and it starts after a good sip of caffè latte: I am ready to face the day. I have a lot of ideas in my head and I want to make them reality.

I had an interesting discussion some time ago with some friends of mine about the difference of cappuccino, caffè latte, and latte macchiato. I am not a coffee expert, but I knew that the difference is in the amount of milk and coffee. The articles I read on the internet are not very clear, however this article here explained by “nientepopodimeno” but Caffè Borbone is very clear and I recommend it to you if you’re interested.

We need first to resolve the performance problem: a dear friend of mine advised me to reduce the size of the map since I would make less effort that way. I decide to throw down the whole dungeon generation algorithm and redo it almost from scratch.

I’ve watched some videos and read some codes online, but this excellent video brought to you by “TheZZAZZGlitch” is really interesting and explains in a visual way an approach to generate dungeons.

The generation algorithm is very interesting: first it generates rooms as I do, then unlike me who immediately tries to connect them, it generates “dumb” rooms (called 1x1) and tries to connect them with existing rooms. It also does another thing: it generates a special border (soft border) that does not allow it to be crossed or passed in any way.

I reason a little bit about how to do that: generate the rooms, okay, which I already had. I can import the 1x1 idea: sounds good to me!

To my surprise it is an approach that works very well: by increasing the number of 1x1 rooms I can increase or decrease the complexity of a dungeon.

Basically it is like connecting multiple rooms together: an approach that works very well!

Before I re-create the collisions and “the walkable and the unwalkable”, I want to make sure that I generate the items and everything that is needed to go from one world to another correctly.

It occurs to me that I have to generate items, money, etc., and these should not be in corridors. Grr, this is difficult.

Going back to the performance problem, I decide to reduce the size of the map to 56x32 pixels. Since I did my algorithm in a way that I can change the size of the map, I can do this without any problem and with some surprise I see that the performance has improved a lot, generations are almost instantaneous.

I am very happy and this is the result!

Things can’t stop here:** I have to generate the items and the money**. I have to generate the exit that will take me to the next level. I have to generate the enemies and some elementary game elements: key, chest, exit, enemy, boss, trap. After all, I can treat everything as walkable/not walkable as well.

I create a dictionary of tuples: the name is something I know, the tuple there is number (which I will need in the final map), the “common” name, and a color that will then be replaced by a texture in the future.

{
 "key": (1, "key", (255, 255, 0)),
 "R#@*JE@": (0, "nothing", (0, 0, 0)),
 ...
}

The idea is to draw the map and depending on what is in the map, draw something different.

The overlapping problem

It also occurs to me that there might be overlapping problems: however, if I calibrate the spawn order well, I should not have such problems.

The overlapping problem is a problem that occurs when I spawn an item, and then I spawn an item on top of it.

For example, I can safely decide to spawn enemies, chests, etc., and only after stairs, since if stairs replace an enemy, it is less serious than having an enemy replace stairs, it would make the game impossible.

Graphically there is not much changes, but in practice I always have an exit and something on my map.

Movement and collisions

Now we have to move on to movement and collisions: I simply have to make a function that checks if I can move on a certain tile, and if yes then move, otherwise not. It will suffice to treat enemies as blocks and everything else as something walkable.

The next step will be to define each entity behavior. Let’s start with stairs -> I decide that every time a valid movement is made events happen, so I use the strategy of the boolean “moved and not moved”. It works.

Enemies AI Idea

Now I have to deal with the AI of the enemies. I want to define different strategies, but for now I am content with a “random” approach.

A first implementation is this: find all the reds, if they can move go in the direction they randomly choose. This approach in terms of memory sucks: it would be better for me in generation phase to save the position of the enemies and update it as they perform movements.

Bugs

But here’s some bugs arise:

if I decide to move on a tile that has already been chosen by an enemy, I am not a solid object so both I and the enemy overlap.
1. solved in a simple way by assigning me the property of being solid
since I have defined that every object when stepped on and is “walkable” becomes a normal tile again, enemies do the same thing with stairs. In other words: the enemy steals the stairs! This is not good and to solve it I have to handle the limit case of the stairs (between them they should not kill each other as they are all solid).

Technically, I could also change the order of generation: I now generate the rooms, generate the dumb rooms, connect them, generate the items and game elements, however, to save resources and time, I could generate the rooms, place the player, place the items generate the 1x1 tiles and then connect them.

Another bug: enemies and I move in the same tile and overlap: this is not good, and it is because I was never updating the fact that the area where I was standing was free and I had moved to another area. Instead, every time I move, I have to set the tile where I am as “walkable” and the new one as “not walkable,” which comes from the fact that I occupy it.

Another approach I came up with is to simply define whether the playing field is walkable or not.

Enemies AI: let’s attack!

The time has finally come: define the IA behind the enemies: meanwhile, I want to define three kind of enemies, one that is very stupid and keeps doing what I have been doing so far (wandering around randomly), one that is smart and chases the player, and the other that is greedy and steals everything stealable

I create the AI for the first and the second kind, but not the third: I have to think about how to implement it.

Now I find myself in endless dungeons. I definitely need to implement a quick attack just to make enemies disappear. For now I settle for “last key pressed is up, so I shoot up”. I can implement it by writing that the last key pressed “looks” in a certain direction, regardless of whether or not you can move.

HUD

It’s late but I can make it!

I take a short break, and after a while, I find out about pr.end_mode_2d() which allows you to draw a HUD.

That’s fantastic! In the top left corner I want the stats counter in general, and at the bottom I want a textbox: the messages go away after two seconds (120 then, because I’m at 60 frames per second) and the hud has to disappear.

It occurs to me to make a buffer for the messages, and eventually show it slowly by removing each string.

Here’s an example and why I told the 120 frames per second thing:

messages_buffer.insert(0, ["Level up! You are now level " + str(player['level']), 120, pr.GREEN])

Messages are placed in a list, and each message is a list of three elements: the message, the number of frames it has to stay, and the color.

At the end of the game loop, I check if the message has to be removed, and if so, I remove it, otherwise decrease the number of frames it has to stay until it reaches 0 and shows the message in the box.

This is the result:

Dungeon Devlog #2

dag7+ifyourenotallmpleaseremovethis@protonmail.com (Dag) — Wed, 05 Jun 2024 22:24:00 +0200

My original idea was to make a dungeon game.

“Damn bro, you just started and you already want to make a dungeon game?”

Yes, I know, but I love dungeon games, and I want to make my own since ever. The most fun part of a dungeon game is the dungeon itself: the rooms, the corridors, the monsters, the traps, the inventory. Everything is random, everything is different every time you play, and that’s addicting.

But, let’s go back to the game.

It is time to make my hands dirty on the actual dungeon creation. Where do I start?

Well, I had seen a video a while back on procedural dungeon map generation. The idea was that first you generated rooms, then you generated corridors. I then decide to set a scary size for the map, like 300x300 because I think it is a good size for a dungeon.

Let’s move on the dungeon generator part: it is slow and has problems.

The idea is to generate the whole map first by defining walkable and non-walkable areas, the player (always a yellow square), draw a green square for each “non walkable square”, then I can move on to fill the entire map with monsters, items, and traps… you know, the usual dungeon stuff.

It works but… the problem is also that I can’t see anything this way, because everything is too big.

I find out about the existence of the game “camera” which serves just as if it were a separate and detached window to the game world. Very pleased about this, I decide to postpone the problem of optimizing things and make them faster until the next day, not before adding some small debugging controls (W and S keys, zoom in or out the view)

I also implemented a small collider with walls, that does not seem to work properly and the classic directional arrow controls for moving my yellow square around.

Here’s the result:

Dungeon Devlog #1

dag7+ifyourenotallmpleaseremovethis@protonmail.com (Dag) — Tue, 04 Jun 2024 21:13:25 +0200

Finally, after some years, I am experimenting for the first time with making video games.

I have always been fascinated by the idea of creating a video game, but I have never had the courage to start. I have always been afraid of not being able to finish it, of not being able to make it as I wanted, of not being able to make it fun.

But this time things are different: I wanted to make a game for GBA, but thanks to a friend of mine who suggested me to use Raylib, a C library for making games, I decided to start with that.

Honestly I was intimidated by the idea of starting from scratch, because many frameworks nowadays I thought were too complex for me. But Raylib is damn simple, and I like it.

I can’t make games from one day to another, it requires a lot of time, work, programming, testing and all the other software development phases. After all I write software for a living, so I know what I am talking about.

Let’s start with a silly thing and make Totti’s Quest, a red square that if it touches another green square, the other one turns yellow and starts the Roma anthem + an image of Totti

The first problem is drawing a square. Well, just check raylib lib! But raylib is a library in C.

My main language is Python: it’s not “I don’t like C”, it’s more like “I use Python every single day, so I am confident with it”.

They are programming languages: exactly like with the normal ones, they work in the same way. The only difference is that C is verbose, I need to manage more things (like structs, dictionaries are not native and so on). Python have a lot of gimmicks that make it easier to use. Since the result is gonna be the same, I decided to use the latter.

Fortunately, raylib was ported to Python so you find these “bindings” that basically make the library suitable for a language that is different from the original one.

I’ve managed to complete the code with a bit of a problem: I can’t get the audio to work because it always clashes.

It occurs to me that I can use boolean variables to indicate states, like “played” or not.

This is an approach that works, and I am happy with it.