DEV Community: Viktor de Pomian Sandell

Game is done...kinda

Viktor de Pomian Sandell — Fri, 27 Mar 2026 12:37:58 +0000

Where we are?

https://depoco.itch.io/holy-carp

Ok, so the game is mostly done. I've uploaded it to itch.io. It's still missing a few elements, but I'll be adding more as I go.

This is only my second game ever, and honestly, I'm pretty happy with how it turned out. Of course, I wanted it to have tons of features and amazing gameplay, but those will come, step by step.

In this post, I'll dive deeper into my GameManager and some refactoring I did, the good stuff that keeps the project tidy and manageable.

What needs to be added

Some of the pixel sprites needs to be fixed, it seems that they got messed up when I imported it into Godot, no idea why.

Sort out the menu and make it look prettier and at the same time add the audio I have + the settings window.

GameManager stuff

So this is my final script for the GameMananger:

extends Node

signal lives_changed(new_lives)
signal score_changed(new_score)


var lives = 3
var current_score = 0

# KEEPING SCORE ---------------------------------

func _update_score(fish_score):
  current_score += fish_score
  score_changed.emit(current_score)

#------------------------------------------------

# HEALTH ----------------------------------------

func _decrease_life():
  if lives > 0:
    lives -=1
    lives_changed.emit(lives)

  if lives == 0:
    _game_over()

#------------------------------------------------

# GAME UI STUFF ---------------------------------

func _game_over():
  var game_over_scene = preload("uid://behejrhw6wlo7")

  var game_over_instance = game_over_scene.instantiate()
  var GameOverCanvas = get_node("/root/MainScene/GameOverCanvas")

  GameOverCanvas.add_child(game_over_instance)

  get_tree().paused = true

#------------------------------------------------

func reset_game():
  lives = 3
  current_score = 0
  lives_changed.emit(lives)
  score_changed.emit(current_score)

It keeps track of score, lives and game over.

This is just a quick update. I'm starting a new game and have a lot on my plate right now, so progress on this post will be occasional.

I'll be adding more to it from time to time. Also, keep an eye out for new posts about my new game. I plan to release Part 1 next week.

My dear readers. Remember that everything I write is not always 100% correct. I do mistakes and I'm a novice at this. So if you find a mistake or just have some random feedback on anything. Please comment!

More sprites, GameManager and refactoring

Viktor de Pomian Sandell — Mon, 23 Feb 2026 13:43:55 +0000

More Sprites

We're making real progress now.

In the last post, I showed the fish and the boat. But that's not all, I've also made a cloud and some water… or rather, the waves.

I pushed the boat down slightly so it looks like it’s actually sitting in the water instead of hovering awkwardly above it.

I thought about animating the waves to move back and forth, but I ran into some weird bugs. Instead of fighting that battle, I parked it for later and moved on.

To make things feel more alive, I added a subtle bobbing effect to the ship. I did this by adding an AnimationPlayer to the Player scene, creating a new animation, and animating the Y position from 0 -> -2 -> 0. Then I set it to loop.

It's a tiny movement, but it makes a big difference. The boat no longer feels static, it gently floats, like it's actually resting on water instead of glued to the screen.

@onready var animation = $AnimationPlayer

To get the animation reference.

func _ready() -> void:
    animation.play("bopp")

This is just to make sure the animation loads and fires once when the game starts.

Yes, I misspelled the name, "bopp."

It works. It does its job. I ain't touching it right now.

For the waves, I added a TileMapLayer as a child node in my Main Scene. I'm not sure if I should have made it its own scene and instantiated it instead, but I’ll figure that out later.

I created a spritesheet specifically for the wave tiles. Going forward, though, I'm planning to move everything into spritesheets instead of having single images scattered all over the project.

This is the spritesheet for the waves(so far):

GameManager and some refactoring

I made some major changes to the code.

Instead of having important logic scattered across multiple places, I decided to centralize most of what I need into a single script called GameManager.

It's very simple. One place to handle shared data and global behavior, things like score, game state, and other logic that multiple scenes depend on.

extends Node

signal lives_changed(new_lives)
signal score_changed(new_score)


var lives = 3
var current_score = 0

# KEEPING SCORE ---------------------------------

func _update_score(fish_score):
  current_score += fish_score
  score_changed.emit(current_score)

#------------------------------------------------

# HEALTH ----------------------------------------

func _decrease_life():
  if lives > 0:
    lives -=1
    lives_changed.emit(lives)

  if lives == 0:
    _game_over()

#------------------------------------------------

# GAME UI STUFF ---------------------------------

func _game_over():
  var game_over_scene = preload("uid://behejrhw6wlo7")

  var game_over_instance = game_over_scene.instantiate()
  var GameOverCanvas = get_node("/root/MainScene/GameOverCanvas")

  GameOverCanvas.add_child(game_over_instance)

  get_tree().paused = true

#------------------------------------------------

The health and game-over systems will come in a future post, they're not fully finished yet, so no point pretending they are.

But the score system? That part is working.

To explain it properly, I need to show parts of the fish script again, specifically the section where the fish interacts with the GameManager.

@export var fish_score = 1

func _on_body_entered(body):
    if body.is_in_group("Player"):
        GameManager._update_score(fish_score)
        queue_free()

I set it up so that when a fish comes into contact with the Player, it calls a function inside the GameManager to calculate the score.

Inside GameManager, the _update_score function updates the total and then emits a signal. That signal is picked up by the UI, which updates the score counter.

Flow looks like this:

Player catches fish -> call _update_score in the GameManager singleton -> current score (starting at 0) gets increased by the fish's value (normal or gold) -> signal is emitted.

That's it.

It took a while to figure out, mostly because I hadn't really worked with singletons in Godot before. Watched a short video, experimented a bit, and eventually it clicked.

In the next post, I'll go deeper into the GameManager, how I connected it to the UI, the health system, and the bomb I added to the game.

My dear readers. Remember that everything I write is not always 100% correct. I do mistakes and I'm a novice at this. So if you find a mistake or just have some random feedback on anything. Please comment!

Enemies, spawns and escalating chaos

Viktor de Pomian Sandell — Mon, 16 Feb 2026 15:54:03 +0000

Enemies

Hmm. They're not really enemies, are they? We're not fighting anything. We're collecting fish.

That reminds me, there's an awesome podcast called No Such Thing as a Fish. Completely unrelated. Anyway.

Back to the game.

The so-called "enemies" are fish falling from the sky, and our job is to gather them. I've made two versions:

Normal fish - worth 1 point
Gold fish - worth 3 points

Yes, I know I mentioned this in the first post. Repetition builds character. Or at least reinforces game mechanics.

I made two fish sprites in Aseprite. Amazing software. Aseprite

I decided to split them into two scenes: normal_fish and gold_fish.

Both scenes use an Area2D as the root node, with a Sprite2D and a CollisionShape2D as children. I went with Area2D because I want the fish to disappear the moment they're collected by the Player.

I also attached a script to each fish.

extends Area2D

@export var fall_speed = 200

func _ready() -> void:
    body_entered.connect(_on_body_entered)

func _process(delta: float) -> void:
    position.y += fall_speed * delta

func _on_body_entered(body):
    if body.is_in_group("Player"):
        queue_free()

This script simply sends a signal and connects to it on the same object, meaning it handles its own collision instead of notifying another node.

So when something enters the Area2D (basically touches it), the script checks if that body belongs to the Player group. If it does, it deletes itself, the fish removes its own node from the scene.

Flow is simple:

Fish falls down -> touches the boat -> script verifies it's the Player -> fish gets deleted from the viewport.

Clean and self-contained.

One important detail: in the Player scene, I added the CharacterBody2D (the root node) to a Group called Player.

That way, checking collisions becomes simple. Instead of hard-referencing a specific node, the fish just asks:

“Is this body in the Player group?”

If yes -> delete fish.

Spawn Logic

The spawn logic took me a while to figure out. It's not 100% polished yet, but it works, and working beats perfection.

I created a Marker2D node called SpawnPoint, and gave it a Timer node as a child, renamed to SpawnTimer.

The idea is simple:
The SpawnPoint decides where things appear.
The SpawnTimer decides when they appear.

Position + timing. That's the whole trick.

I moved the SpawnPoint to the middle of the screen and pushed it straight up, just outside the visible area. That way, the fish spawn off-screen and fall into view.

On the SpawnTimer, I only changed one thing: Wait Time = 3.0 seconds.

Then I attached a script to SpawnPoint, because a timer that just sits there politely counting to three doesn't actually spawn anything on its own.

extends Marker2D

var marker_pos = self.global_position.x
var viewport_size_x

const GOLD_FISH = preload("uid://cr8ekydc55yid")
const NORMAL_FISH = preload("uid://b0uukpf476i0q")

@onready var spawn_timer: Timer = $SpawnTimer
@onready var spawn_objects_group: Node = $"../SpawnObjectsGroup"

func _ready():
    viewport_size_x = get_tree().root.get_visible_rect().size.x
    spawn_timer.start()

func _on_spawn_timer_timeout() -> void:
    _spawn_random_object()

func _spawn_random_object() -> void:
    var spawn_random_position = randf_range(32, viewport_size_x - 32)
    var gold_fish_chance = 0.2 # This means a 10% chance
    var object
    if randf() < gold_fish_chance:
        object = GOLD_FISH.instantiate()
    else:
        object = NORMAL_FISH.instantiate()
    object.position.x = spawn_random_position
    spawn_objects_group.add_child(object)

Explanation:

var marker_pos = self.global_position.x
This grabs the X position of the Marker2D in global space.

We need that value so we know exactly where to spawn the fish horizontally in the world. Since the marker is positioned just above the screen, its global position becomes the reference point for where new objects appear.

var viewport_size_x
This creates a variable called viewport_size_x.

Its job is to store the width of the viewport so we can use that value later.

const GOLD_FISH = preload("uid://cr8ekydc55yid")
const NORMAL_FISH = preload("uid://b0uukpf476i0q")
These are simply references to the two scenes I created earlier. By preloading them, I can quickly instantiate either the gold fish or the normal fish without repeatedly typing long paths.

It also makes the code cleaner and easier to read.

Small tip: in Godot, you can hold CTRL and drag the scene file directly into the script, and it will automatically create the correct preload reference for you.

@onready var spawn_timer: Timer = $SpawnTimer
@onready var spawn_objects_group: Node = $"../SpawnObjectsGroup"
Same idea here. Instead of manually typing node paths and hoping you don't mess them up, you can CTRL + drag the nodes directly from the Scene Tree into the script.

viewport_size_x = get_tree().root.get_visible_rect().size.x
spawn_timer.start()
The first line grabs the exact width of the viewport (X axis). I don’t bother with Y because the spawn position is always off the top of the screen, we only care about horizontal placement.

The second line starts the timer so spawning actually begins when the game launches. That's why it's in _ready(), it only needs to fire once, right at the start.

func _on_spawn_timer_timeout() -> void:`
    `_spawn_random_object()

This function is connected to the timeout signal of SpawnTimer.

When the timer hits 3 seconds, it fires _on_spawn_timer_timeout(), which then calls _spawn_random_object().

That _spawn_random_object() function is where the real magic happens, this is where the fish actually appear in the world.

func _spawn_random_object() -> void:
    var spawn_random_position = randf_range(32, viewport_size_x - 32)
    var gold_fish_chance = 0.2 # This means a 20% chance
    var object
    if randf() < gold_fish_chance:
        object = GOLD_FISH.instantiate()
    else:
        object = NORMAL_FISH.instantiate()
    object.position.x = spawn_random_position
    spawn_objects_group.add_child(object)

This function randomly spawns either a normal fish or a gold fish somewhere along the screen width. The gold fish is rarer, appearing only about 20% of the time.

Once a fish is chosen and its horizontal position is set, it's added to the game world, specifically into spawn_objects_group. This node acts as a container for all spawned fish, keeping the scene organized instead of scattering fish everywhere in the root.

Oh, and by the way. I also finished the sprite for my boat.

My dear readers. Remember that everything I write is not always 100% correct. I do mistakes and I'm a novice at this. So if you find a mistake or just have some random feedback on anything. Please comment!

From empty scene to playable prototype

Viktor de Pomian Sandell — Fri, 13 Feb 2026 17:17:36 +0000

Creating scenes

First thing first. Create my project.

Holy Carp! Baaam. An absolutely legendary name for my soon-to-be amazing game.

Now we've got our very first scene, let's call it main_scene. This is the mothership. The place where I'll instantiate all the other scenes.

Oh, and by the way. Godot works with scenes instead of traditional objects. A very simplified explanation from my part.

Main Scene

I changed the window size of my game by going to Project -> Project Settings -> Display (Window) and setting the viewport width and height to 720×1280. It's a vertical game, after all.

But since I'm developing on my laptop, that resolution doesn't exactly fit on my screen. The viewport would stretch beyond my screen height, which is… not ideal.

So I did what any reasonable developer does, I googled it.

Turns out, in Godot you can use Window Width Override and Window Height Override. Basically, you keep your actual game resolution at 720×1280, but tell the editor to display it smaller while you're working.

So for now, I set the override to 360×640. Same aspect ratio. Half the size. Much less pain.

That's pretty much everything I did for the main scene.

Wait. Not everything.

I also added a Camera and positioned it over the viewport. Do I actually need it? Not entirely sure. So I had to google this as well.

In Godot, a Camera2D controls what part of the world you see. If your game is static and nothing moves outside the screen, you technically don't need one. But the second you want scrolling, following a player, zooming, or any kind of movement? You'll want that camera there.

So I'm going to keep it for the future, or just pretending I know what I’m doing.

Node Structure & Project Structure

For this part, I actually did a little homework on what's considered "best practice", basically, how to set things up now so I don't hate myself later.

I really want to keep my project tidy, and a few people suggested breaking scripts into smaller Nodes as children of the root node. At first, I had no clue what that even meant, but after some Googling, it clicked. I'll dive deeper into this when I cover my Player scene.

When it comes to my project structure, its very straight forward, at least for a small project like this:

Setting up the Player

Now it's time for the Player scene.

I started with a CharacterBody2D(CB2) node, because I don't need physics for this game. If I did, I'd probably go with a Rigidbody2D… I think. For now, CB2 is plenty. I didn't mess with any of its settings at the start, mostly because I had no idea what things did.

Next, I added a CollisionShape2D as a child of the Player node(CB2). This is crucial, without it, I can't "catch" the falling fish or get pummeled by the bad stuff.

Finally, I added a Sprite2D node and the default icon.svg as its sprite, just so something actually shows up while I'm working.

This is coming along nicely.

But now we actually need to move the Player. And this is where key inputs and scripts does its thing.

Basic Movement

I went to Project -> Project Settings -> Input Map at the top, and added a few actions:

left - triggered by the A key and the left arrow
right - same as left but opposite keys
helper - triggered by the Space key

Now that the key mapping is done, I should be able to move this bad boy around the viewport, right?

Nope. Not that easy. We still have to tell this mess what to do. Scripts, people. Scripts.

Enter GDScript and the appointed scripts.

Like I mentioned earlier, we need to break our scripts up. I don't want one giant 10,000+ line monstrosity, that's a nightmare to manage.

So, I made a simple node called MovementScriptNode and made it a child of the Player node. On this node, I attached a script to handle movement.

But there's a catch, this script doesn't automatically know that it's supposed to move the Player, because right now it's just a lonely node floating in space.

We need to tell the Player node to use the info in the script attached to MovementScriptNode. We do this by:

extends CharacterBody2D

@onready var movement = $MovementScriptNode

func _physics_process(delta: float) -> void:
    movement.move_player(self, delta)

So what this code means is, in very short terms: "Whattup MovementScriptNode, please move me." the move_player is a function in MovementScriptNode. As you can see below:

extends Node

@export var speed = 400

func move_player(character, _delta):
    var input_direction = Input.get_axis("left", "right")
    character.velocity.x =  input_direction * speed

    if character.velocity.x > 0:
        character.get_node("Sprite2D").flip_h = true
    elif character.velocity.x < 0:
        character.get_node("Sprite2D").flip_h = false

    character.move_and_slide()

I could go line by line here, if you want, let me know in the comments.

Basically, the movement script does this: reads input, sets the Player's velocity, flips the sprite, and then tells the Player to actually move. It uses a parameter called character, which in the Player script is passed as self.

Now the Player moves like it should… except it can wander off the viewport. I'll fix that later, once I figure out how. (ignore the size of the Player node.)

My dear readers. Remember that everything I write is not always 100% correct. I do mistakes and I'm a novice at this. So if you find a mistake or just have some random feedback on anything. Please comment!

My f...second game

Viktor de Pomian Sandell — Thu, 12 Feb 2026 15:28:18 +0000

Hello there! and welcome!

I originally planned to start documenting my journey when I made my first game. You can check it out here: Hostbound. I built it for a horror game-jam. It’s not exactly terrifying, but making it was meaningful.

The problem is… I barely remember what I learned. The game was uploaded on November 5th, 2025, and I haven’t looked at Godot or GDScript since. Real life happened.

Anyway. Enough nostalgia.

I need a new idea. And I hate learning purely through tutorials. Small stuff is fine, but listening to the same guy explain the same thing for 36 hours feels like psychological torture. So I’m doing this the only way I know how and that is by actually making something.

The idea

A simple 2D game. Mostly because I can handle intermediate pixel art without losing my sanity.

The core concept:
Fish fall from the sky. You catch them with your boat. You avoid bad stuff. Simple, slightly stupid. Perfect.

Good:

Normal fish(lets just do medium size)
Rare fish(golden fish? treasure chest with a fish icon?)

Bad:

Cans
Knifes
Spiky sea urchins?

Power-ups?

Clock -> slow motion for 6 seconds
Magnet -> pulls fish toward your boat

Health system: hearts.
Max 3 hearts. Falling hearts can restore lost health.

So the game goes like this(for now):

You start with 3 lives.
Catch fish -> +1 score.
Rare fish, special objects -> +3 score.
Catch trash -> Lose 1 life.
If a fish hits the water... not decided this yet.
Spawn rate increases over time -> more chaos

I might add a helper later on. For example a seagull that swoops in when you press Space. But first we are making a MVP

That's the plan. Thanks for reading, and stay tuned for more to come.