DEV Community: Kyle Homen

Release 0.4 Results

Kyle Homen — Fri, 12 Dec 2025 23:00:43 +0000

We're at the end of the road now. Today I submitted the pull request to display top categories as individual tabs to the Pandora project.

This ended up being a fun little challenge and I'm really happy with how it turned out.

What I Did

The goal was to add a setting to turn this default, tree-style look:

Into one with tabs. The logic for creating new categories and entities already existed, so this was mostly UI.

Building the Tab system

The core logic lives in the PandaEditor scene. Within the Godot editor itself, you can add nodes to each scene, including containers and UI elements.

I started by adding a TabContainer to the scene and setting it to hidden. This will eventually be populated with tabs when the setting is chosen and become visible.

pandora-settings holds the code for adding settings, so there I added a boolean toggle to swap to tab view:

const USE_CATEGORY_TABS = "pandora/use_category_tabs"

static func get_use_category_tabs() -> bool:
    return ProjectSettings.get_setting(USE_CATEGORY_TABS, false)

Next, I added tab populating to pandora-editor.gd. There already existed a function called _populate_data() that handled data by default, but I needed to modify it to check if the tabs setting was set:

    var use_tabs = PandoraSettings.get_use_category_tabs()

    if use_tabs:
        await _populate_tabs(data)
    else:
        tree.set_data(data)

Then I created the _populate_tabs() function to take the data, and instead of mapping it to a tree, create a tab for each root category:

# Create tabs for root categories
    for i in range(root_categories.size()):
        var tab_content = Control.new()
        category_tab_container.add_child(tab_content)
        category_tab_container.set_tab_title(i, root_categories[i].get_entity_name())

Now I needed to filter the tree to show only the children of the selected category when the tab was selected, so I created the _on_tab_changed() function:

func _populate_tabs(root_categories: Array[PandoraEntity]) -> void:
    # ... create tabs ...

    # Store root categories
    category_tab_container.set_meta("root_categories", root_categories)

    # Select tab
    category_tab_container.tab_changed.connect(_on_tab_changed)

func _on_tab_changed(tab_index: int) -> void:
    var root_categories = category_tab_container.get_meta("root_categories", []) as Array
    var selected_category = root_categories[tab_index]

    # Filter tree to show only entities in the selected category
    var filtered_data:  Array[PandoraEntity] = []
    filtered_data.assign(selected_category._children)
    tree.set_data(filtered_data)

Now clicking on the tabs filtered the tree to only show the root categories' child nodes. From here, functionality worked like the original tree view and you could add and remove entities from each tab, but it was missing something crucial: The tab categories could not be removed or renamed, and we needed a way to create categories with a '+' button.

I started by adding the '+' tab to _populate_tabs(), created after the root categories:

func _populate_tabs(root_categories:  Array[PandoraEntity]) -> void:
    # ... create category tabs ...

    # Add '+' tab for creating new root categories
    var add_tab_content = Control.new()
    add_tab_content.name = "+"
    category_tab_container.add_child(add_tab_content)

then updated _on_tab_changed() to detect when the '+' tab was clicked:

func _on_tab_changed(tab_index:  int) -> void:
    var root_categories = category_tab_container.get_meta("root_categories", []) as Array

    # Create new root category if '+' tab is selected
    if tab_index >= root_categories.size():
        _create_root_category()
        return

To rename and delete categories, I determined that adding a context menu was the best option, and mapped it to the right mouse button:

func _on_tab_bar_input(event: InputEvent) -> void:
    if event is InputEventMouseButton and event.button_index == MOUSE_BUTTON_RIGHT and event.pressed:
        var tab_bar = category_tab_container.get_tab_bar()
        var clicked_tab = tab_bar.get_tab_idx_at_point(event.position)

        if clicked_tab >= 0:
            var root_categories = category_tab_container.get_meta("root_categories", []) as Array

            # Don't show menu for '+' tab
            if clicked_tab >= root_categories.size():
                return

            # Store which tab was clicked
            category_tab_container.set_meta("context_menu_tab", clicked_tab)

            # Show context menu
            tab_context_menu.position = tab_bar.get_screen_position() + event.position
            tab_context_menu.popup()


func _on_tab_context_menu_pressed(id: int) -> void:
    var clicked_tab = category_tab_container.get_meta("context_menu_tab", -1)
    if clicked_tab < 0:
        return

    var root_categories = category_tab_container.get_meta("root_categories", []) as Array
    if clicked_tab >= root_categories.size():
        return

    var category = root_categories[clicked_tab]

    match id:
        0:  # Rename
            _show_rename_dialog(category, clicked_tab)
        1:  # Delete
            _show_delete_confirmation(category, clicked_tab)

I also went back and hid the original create category button and needed to make the create entity button enabled when in tab view. Oh, and I need to make the category properties appear when the tab was selected, and probably a few other things I forgot. But here is the finished view:

and the setting toggle in project settings:

From here there was one last issue I found, and that was that the setting didn't automatically take and I needed to reload the project each time. I found a simple way to do that by adding a settings listener in the ready() function and re-populating the data (this will see that the category tab setting is true and switch to tab view):

func _ready() -> void:
    ProjectSettings.settings_changed.connect(_on_settings_changed)

func _on_settings_changed() -> void:
    _populate_data()

... and that's about it I think. I managed to learn more about GDScript and Godot engine through adding this feature. Everything is a node! I learned to work with signals, and manage different UI states. I think it turned out great, and I got some positive feedback right away from the maintainers and only need to make some minor changes to rename a node and add % notation.

Release 0.4 Results

Kyle Homen — Fri, 12 Dec 2025 23:00:43 +0000

We're at the end of the road now. Today I submitted the pull request to display top categories as individual tabs to the Pandora project.

This ended up being a fun little challenge and I'm really happy with how it turned out.

What I Did

The goal was to add a setting to turn this default, tree-style look:

Into one with tabs. The logic for creating new categories and entities already existed, so this was mostly UI.

Building the Tab system

The core logic lives in the PandaEditor scene. Within the Godot editor itself, you can add nodes to each scene, including containers and UI elements.

I started by adding a TabContainer to the scene and setting it to hidden. This will eventually be populated with tabs when the setting is chosen and become visible.

pandora-settings holds the code for adding settings, so there I added a boolean toggle to swap to tab view:

const USE_CATEGORY_TABS = "pandora/use_category_tabs"

static func get_use_category_tabs() -> bool:
    return ProjectSettings.get_setting(USE_CATEGORY_TABS, false)

    var use_tabs = PandoraSettings.get_use_category_tabs()

    if use_tabs:
        await _populate_tabs(data)
    else:
        tree.set_data(data)

Then I created the _populate_tabs() function to take the data, and instead of mapping it to a tree, create a tab for each root category:

# Create tabs for root categories
    for i in range(root_categories.size()):
        var tab_content = Control.new()
        category_tab_container.add_child(tab_content)
        category_tab_container.set_tab_title(i, root_categories[i].get_entity_name())

Now I needed to filter the tree to show only the children of the selected category when the tab was selected, so I created the _on_tab_changed() function:

func _populate_tabs(root_categories: Array[PandoraEntity]) -> void:
    # ... create tabs ...

    # Store root categories
    category_tab_container.set_meta("root_categories", root_categories)

    # Select tab
    category_tab_container.tab_changed.connect(_on_tab_changed)

func _on_tab_changed(tab_index: int) -> void:
    var root_categories = category_tab_container.get_meta("root_categories", []) as Array
    var selected_category = root_categories[tab_index]

    # Filter tree to show only entities in the selected category
    var filtered_data:  Array[PandoraEntity] = []
    filtered_data.assign(selected_category._children)
    tree.set_data(filtered_data)

I started by adding the '+' tab to _populate_tabs(), created after the root categories:

func _populate_tabs(root_categories:  Array[PandoraEntity]) -> void:
    # ... create category tabs ...

    # Add '+' tab for creating new root categories
    var add_tab_content = Control.new()
    add_tab_content.name = "+"
    category_tab_container.add_child(add_tab_content)

then updated _on_tab_changed() to detect when the '+' tab was clicked:

func _on_tab_changed(tab_index:  int) -> void:
    var root_categories = category_tab_container.get_meta("root_categories", []) as Array

    # Create new root category if '+' tab is selected
    if tab_index >= root_categories.size():
        _create_root_category()
        return

To rename and delete categories, I determined that adding a context menu was the best option, and mapped it to the right mouse button:

func _on_tab_bar_input(event: InputEvent) -> void:
    if event is InputEventMouseButton and event.button_index == MOUSE_BUTTON_RIGHT and event.pressed:
        var tab_bar = category_tab_container.get_tab_bar()
        var clicked_tab = tab_bar.get_tab_idx_at_point(event.position)

        if clicked_tab >= 0:
            var root_categories = category_tab_container.get_meta("root_categories", []) as Array

            # Don't show menu for '+' tab
            if clicked_tab >= root_categories.size():
                return

            # Store which tab was clicked
            category_tab_container.set_meta("context_menu_tab", clicked_tab)

            # Show context menu
            tab_context_menu.position = tab_bar.get_screen_position() + event.position
            tab_context_menu.popup()


func _on_tab_context_menu_pressed(id: int) -> void:
    var clicked_tab = category_tab_container.get_meta("context_menu_tab", -1)
    if clicked_tab < 0:
        return

    var root_categories = category_tab_container.get_meta("root_categories", []) as Array
    if clicked_tab >= root_categories.size():
        return

    var category = root_categories[clicked_tab]

    match id:
        0:  # Rename
            _show_rename_dialog(category, clicked_tab)
        1:  # Delete
            _show_delete_confirmation(category, clicked_tab)

and the setting toggle in project settings:

func _ready() -> void:
    ProjectSettings.settings_changed.connect(_on_settings_changed)

func _on_settings_changed() -> void:
    _populate_data()

Release 0.4 Update

Kyle Homen — Wed, 10 Dec 2025 23:10:00 +0000

This past week I've been trying to play around with the pandora plugin and analyze the codebase. At least, that was the plan. Instead, I've been trying to get the plugin to actually load.

What I thought I'd have done by now is install the plugin, poke around the code, and sketch out the tabs implementation for the issue. But, so far I've been debugging why it wouldn't load.

I grabbed the latest release of Pandora, dropped it into a test project, enabled it in the plugins menu, and was immediately greeted with this lovely wall of errors:

ERROR: res://addons/pandora/model/entity. gd:606 - Parse Error:  Identifier "Pandora" not declared in the current scope. 
ERROR: res://addons/pandora/model/entity.gd:622 - Parse Error: Identifier "Pandora" not declared in the current scope.
ERROR: res://addons/pandora/model/entity.gd:627 - Parse Error: Identifier "Pandora" not declared in the current scope.
... 
(and about 50 more just like it)

This is apparently a known problem in Godot plugins, but it's also something that can break depending on your Godot version. I'm using 4.5.1, and something about how it loads plugins must have triggered this issue.

So far now, I need to work directly with the source repository instead of using a release. The repo has the correct project configuration already set up.

So, after setting that up and actually using the plugin, this is what you see:

As you can see, all the categories show up in a tree view on the left side of the app. If you have a lot of categories, the tree gets long and cluttered and involves a lot of scrolling. So now I need to add a toggleable setting to make these categories show up as tabs, similar to VSCode:

From analyzing the code, what I understand so far is that clicking "Create Category" calls Pandora.create_category(), and the tree updates. Settings can be modified in pandora_settings.gd, so I'll need to research how to add a toggle setting for switching to tabs. To make the tabs appear, this is where it's more involved. I will need to figure out how to modify the scene structure to show tabs instead of the tree, keeping in mind the additional child nodes will need to be visible as well.

If all goes well, this new feature shouldn't be too difficult to implement.

Project Plan for OSD Release 0.4

Kyle Homen — Wed, 03 Dec 2025 19:23:39 +0000

My plan for the final release is to contribute to a Godot add-on called Pandora. I have a big love for RPG games, and was researching tools to help build RPGs in the Godot engine when I found this addon, which simplifies adding and handling systems such as skills, items, and characters.

I've chosen this project because of my interest in the genre that it is used for, and because I want to use this addon for my own project moving forward. This will be a linear progression from coding games to coding tools for the games.

The feature I'd like to work on has been open since 2023, but the project is still slowly being contributed to. There are a few other open issues as well, depending on how complex this one ends up being, but for now I want to focus on this. Having never worked on a tool for an existing engine, this will be something new that I'll have to learn.

It's a straightforward feature to add a setting that lets users switch from the current tree view (all categories in one list) to a tabbed view (each top category gets its own tab).

This week, I need to first see how this addon works. I'll start a project and play around with the addon to get an understanding of how addons work, and how the categories currently look and why a tabbed view might be a good feature to add.

After that, I'll need to analyze the code and start testing how things change.

Ultimately my goal is to get more comfortable with creating games using Godot and working with addons to the engine. And in the future, I hope to create an addon of my own.

Contributing to Threadbare

Kyle Homen — Sat, 22 Nov 2025 00:50:30 +0000

For the second pull request I decided to look for another game project, one that was more mature than ShooterCarnival. This led me to stumble upon Threadbare, which was another collaborative open-source game, this time in a top down style. Since this game was further along, I hoped that I'd be able to implement something more advanced.

The first thing I looked at was a UI bug where the movement hint was misaligned and not at the bottom of the viewport. After taking the time to explore the Threadbare repository and structure, I found where the main scene was and got around to seeing how the objects were laid on the scene.

The fix turned out to be a really simple variable change, but it did take some time to get to know the project. Nonetheless, I wanted to do more than this.

I actually noticed a few things like missing audio while playtesting, so I looked for an issue like that to work on and found this.

Adding audio required creating AudioStreamPlayer nodes in each scene that linked to audio files (The 'click' noises were created in a separate issue but not implemented yet), and I had the menu working after a bit of trial and error but quickly realized how unwieldly it would be to have to make the same audio nodes in every scene. Therefore, I researched how to implement it globally and found that I could create an AudioManager file and link it globally in the project settings so that every scene could access the variables in it. This meant that I only needed to call a function for each button press.

AudioManager file:

@tool
extends Node

@onready var ui_click_sound: AudioStreamPlayer = %Click
@onready var ui_click_back_sound: AudioStreamPlayer = %ClickBack
@onready var ui_click_toggle_sound: AudioStreamPlayer = %ClickToggle


func play_ui_click():
    ui_click_sound.play()


func play_ui_click_back():
    ui_click_back_sound.play()


func play_ui_click_toggle():
    ui_click_toggle_sound.play()

This is a way cleaner solution, and only needs to be called like this:

func _on_continue_button_pressed() -> void:
    AudioManager.play_ui_click()

No imports or adding variables or anything. Neat.

After filing the pull request I found a couple interesting things about their workflow. First it rejected the formatting on the new .gd file I created by automatically running a linter and formatter, but it also failed a test because I was missing copyright text information at the top of the file.

It's required that the file has this at the start:

# SPDX-FileCopyrightText: The Threadbare Authors
# SPDX-License-Identifier: MPL-2.0

Which I found is copyright header information using the Software Package Data Exchange format. Threadbare uses the REUSE specification which specifies that all files in a repository are labelled with their license in a machine readable way.

After fixing those minor things (I just installed and ran gdformat on my own), I later noticed there was Github Action workflow that created a playable version of the game, which is great. You can play it here to see the audio in action in the main menu.

I didn't fully close the issue with this pr (adding audio to -every- button instance), but I think I provided the means of doing so. I mostly want to make sure the maintainers are happy with this approach before hunting down every menu in the game. All in all this release has made me more comfortable with contributing to Godot engine games, and I'm finding it really enjoyable as a way to learn how to use the engine. My biggest barrier to starting my own projects is my lack of knowledge, so if I tried to start a project in Godot from scratch I would just keep getting in my own way. Right now I'm getting some great experience implementing things in different types of games, and I plan to contribute to a Godot addon as well, if not try to contribute to Godot itself again.

OSD600: Lab 9

Kyle Homen — Fri, 21 Nov 2025 18:37:35 +0000

This week we're releasing version 1.0.0 of our repository context packager. This was an interesting process, and easier than I expected, but a little tricky to set up right.

I followed this guide to packaging python project using PyPI. I chose the backend setuptools since it is the most traditional and widely used packaging tool.

Release Process

First thing I needed to do was restructure my project. I needed to move everything into a repository_context_packager directory and rename my main script to scan_repo.py with an underscore, because Python packaged need underscores. I already had an __init__.py file, but had to move it into the main directory, so this ended up being the new directory structure:

Next I created the pyproject.toml file to configure the package metadata, dependencies, and the CLI entry point to allow users to run scan-repo from the command line.

Now it was time to build and test the package. This was done by installing the build tool with pip install build twine and running python -m build to create the necessary files in a dist/ folder. Then I needed to make an account to upload to Test PyPI to make sure everything was in working order before uploading to the real PyPI. Both sites required making an account, and setting up 2-factor authentication before I could generate the API key necessary to upload builds.

What I Learned

The biggest "aha!" moment was understanding relative imports after getting a bunch of errors. When your code is a script, you use from analyzer import cli, but once it's a package, you need from .analyzer import cli. I had to change every single import statement in my code, including imports between modules in my analyzer folder.

I also learned the hard way that you can't delete or replace versions on PyPI. I accidentally uploaded broken test versions (1.0.1, 1.0.2) to the real PyPI after forgetting to remove them, and once they're up, they're permanent for that version number. I guess I had made them to test, and when I removed and rebuilt version 1.0.0 for the real PyPI, it uploaded the other two at the same time. I had to yank those releases (which hides them from normal pip installs) and will need to upload 1.0.3 as my next version now.

Code Alterations

On top of the structure changes and the addition of the pyproject.toml file, I needed to update my GitHub Actions workflow to run python -m repository_context_packager.scan_repo --help instead of directly calling the script. This was due to changing to relative imports, and it took me a few pushes to realize I had broken this.

User Testing

I had my friend from my last co-op test the installation and it went off without a hitch. Of course, he decided to run it on a huge Github project he had on his computer and it took like 5 mins to get through it but it -did- work exactly as was laid out in the instructions and exactly as I had hoped.

Installing and Running

Installing is really simple now. Just run:

pip install repository-context-packager

Then to use it:

scan-repo .                              # Analyze current directory
scan-repo ./project -o output.md         # Save to file
scan-repo . --recent --remove-comments   # Recent files only, no comments

More detailed usage is outlined in the README.

Overall, it was a good learning experience. The official Python packaging tutorial made it way easier than I expected, and now anyone can install my tool with one command instead of cloning the repo and setting up dependencies manually. The hardest part was definitely getting the imports right- I must have uploaded five broken versions to Test PyPI before I got them all fixed!

Continuing with ShooterCarnival

Kyle Homen — Tue, 18 Nov 2025 22:14:26 +0000

It's been a few weeks since I contributed to ShooterCarnival, and it was fun to see where they had taken it in that time. Slowly, but surely, they were updating the project and adding features, such as the shooting and enemies spawning.

I decided to go in and try to add some new features as well. I found this issue open that was asking for someone to implement the bullet and player collisions with the enemy sprites, which felt like a step up from my last contribution and a good opportunity to learn more GDScript.

I started by learning how to add the sprite node and rig it as an animation, which I actually did through the Godot editor and not through code. It was simply easier to make the new node and select the animation frames this way.

The rest of the work was through the code. I implemented the die() function that swapped the enemy sprite to the explosion sprite, disabled collisions and played the animation:

func die() -> void:
    if is_dying:
        return

    # Mark as dying
    is_dying = true
    speed = 0

    # Disable collision
    collision_shape.set_deferred("disabled", true)

    # Play explosion animation
    sprite.visible = false
    explosion_sprite.visible = true
    explosion_sprite.play("explode")
    explosion_sprite.connect("animation_finished", _on_explosion_sprite_animation_finished)

Next was triggering the die function when the bullet or player touched an enemy. When two Area2D nodes overlap, they emit signals. We use area_entered(area) to look for when another Area2D node enters the area to trigger the dying animation, as well as remove the bullet (or player).

func _on_area_entered(target: Node2D) -> void:
    # Bullet collision handling
    if target.is_in_group("bullets"):
        # Remove the bullet
        target.queue_free()
        # Explode the enemy
        die()

    # Player collision handling
    if target.is_in_group("player"):
        # Explode the enemy
        die()
        # Hide player
        target.hide()
        # TODO: Game over, or notify player of hit

For now, the issue just asks to hide the player, so that is how I implemented it.

After setting up the groups and writing the area entered logic for bullets as well, we get this, which looks ready for a pull request.

OSD600: Lab 8

Kyle Homen — Sat, 15 Nov 2025 01:17:51 +0000

This week I added a GitHub Action Continuous Integration Workflow (say that 10 times fast) to my project. This was interesting as I've now encountered this in a few projects I contributed to during Hacktoberfest and was eager to implement it to my own work.

Implementing it was pretty simple, I just used a suggested workflow

Which already had everything I needed, including running a linting step using flake8. The only small step I added was to run a bit of a smoke test by running the --help and --version features of the cli, which I saw suggested.

name: CLI Tester

on:
    push:
        branches: ["main"]
    pull_request:
        branches: ["main"]

permissions:
    contents: read

jobs:
    build:
        runs-on: ubuntu-latest

        steps:
            - uses: actions/checkout@v4
            - name: Set up Python 3.10
              uses: actions/setup-python@v3
              with:
                  python-version: "3.10"
            - name: Install dependencies
              run: |
                  python -m pip install --upgrade pip
                  pip install flake8 pytest
                  if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
            - name: Lint with flake8
              run: |
                  # stop the build if there are Python syntax errors or undefined names
                  flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
                  # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
                  flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
            - name: Run CLI smoke test
              run: |
                  python scan-repo.py --help
                  python scan-repo.py --version
            - name: Test with pytest
              run: |
                  pytest

A funny little issue I ran into when testing my pull request, was that one of my tests was passing on my local machine but failing when tested on GitHub:

Pass:

Same test failing:

And it turns out when I'm testing for the exact same times (30 day old file vs 30 day threshold), on GitHub it's probably taking slightly longer between when the mod_time is calculated and when the function calls time.time(), resulting in it failing.. I ended up just writing a separate unit test to test exact time between modified time and threshold to avoid that:

def test_file_modified_exactly_at_threshold():
    """Test file modified exactly at the threshold boundary."""
    with tempfile.NamedTemporaryFile(mode='w', delete=False) as f:
        f.write("test")
        temp_path = f.name

    try:
        # Fix both timestamps to eliminate timing variance
        fixed_current_time = 1000000.0
        fixed_mod_time = fixed_current_time - (30 * 24 * 60 * 60)

        with patch('time.time', return_value=fixed_current_time):
            with patch('os.stat') as mock_stat:
                mock_stat.return_value = MagicMock(st_mtime=fixed_mod_time)

                result = is_recently_modified(temp_path, recent_day=30)
                assert result is True
    finally:
        os.unlink(temp_path)

My partner's testing setup wasn't too different from mine as we are both writing our programs in python and using pytest for our testing suite. Our actual projects function differently, however, so I did have to tailor the tests to their project by using the setup_method() to create an instance of the FileProcessor() class.

    def setup_method(self):
        self.processor = FileProcessor()

Pull Request

Now that I've set up Continuous Integration for myself, I can see how useful it can be to automatically test any additions to the code without the maintainer pouring through and making sure nothing breaks. It must save hours and hours of time for bigger projects where one small change could unknowingly create a butterfly effect of bugs somewhere else in the code- and having an automatic CI workflow set up just eliminates any of that guesswork and makes sure that at the bare minimum what's being added isn't breaking any core functionality of the code.

OSD600: Lab 7

Kyle Homen — Fri, 07 Nov 2025 17:12:23 +0000

This week I worked on adding some automated testing to the repository-context-manager.

Since the project is written entirely in Python, naturally I chose to use pytest as my testing framework. I had some experience with pytest from my previous internship and seems like the go-to option to write tests with. To be honest, I didn't even check if there was another option.

To get started with pytest, of course you need to install it. I used the pip installer to install it directly in VSCode terminal by running: pip install pytest.

Off the rip I was having some trouble running my first test, and found out that I needed to create a configuration file for pytest called conftest.py. With this configuration file, I needed to indicate the project root so that my test folder could interact with the analyzer module that held all of my code:

project_root = Path(__file__).parent.parent
sys.path.insert(0, str(project_root))

With that out of the way, the first few tests were up and running. On my first test file, I decided to test the recently added remove lines feature that I added. I chose this function because I knew this one needed a little extra work to eventually add the ability to remove inline comments, and having some robust testing to make sure that feature works without removing, for example, strings with hash symbols inside them.

Here's an example of the one test that does not pass because that feature isn't added yet:

    def test_inline_hash_comment(self):
        """Test removal of inline hash comments."""
        code = 'x = 5  # This is an inline comment'
        expected = 'x = 5'
        assert remove_hash_comments(code) == expected

My second tested function looked at checking the output for logging messages, which involved using the built in caplog feature of pytest. At first I was not finding the messages that SHOULD have been properly logged, but after a bit of research I found that, by default, caplog is only capturing at the warning level, and my logging was at the debug level.

This was fixed by adding the debug level to the conftest.py file:

logging.basicConfig(level=logging.DEBUG)

After that, I could check the caplog output if a certain debug statement was triggered:

    def test_config_file_not_found(self, caplog):
        """Test behavior when config file doesn't exist."""
        assert load_config_file("/nonexistent/path/config.toml") == {}
        assert "No config file found" in caplog.text

Finally, when writing tests for my final function (the is recently modified function that checks if a file has been recently modified), I found that I was repeating code just checking the different inputs (using a mock filetime and setting a recent threshold). I found that pytest has a built in parametrization feature that allows you to write one unit test and feed it multiple parameters to test multiple inputs at once like so:

@pytest.mark.parametrize("days_ago,threshold,expected", [
    (1, 7, True),    # 1 day ago, 7-day threshold -> recent
    (5, 7, True),    # 5 days ago, 7-day threshold -> recent
    (10, 7, False),  # 10 days ago, 7-day threshold -> not recent
    (0.5, 1, True),  # 12 hours ago, 1-day threshold -> recent
    (2, 1, False),   # 2 days ago, 1-day threshold -> not recent
    (30, 30, True),  # 30 days ago, 30-day threshold -> recent
    (31, 30, False),  # 31 days ago, 30-day threshold -> not recent
])
def test_various_time_thresholds(days_ago, threshold, expected):
    """Test various combinations of file age and thresholds."""
    with tempfile.NamedTemporaryFile(mode='w', delete=False) as f:
        f.write("test")
        temp_path = f.name

    try:
        # Mock modification time
        mod_time = time.time() - (days_ago * 24 * 60 * 60)

        with patch('os.stat') as mock_stat:
            mock_stat.return_value = MagicMock(st_mtime=mod_time)

            result = is_recently_modified(temp_path, recent_day=threshold)

            assert result == expected
    finally:
        os.unlink(temp_path)

This test creates a temporary file, modifies the recently modified time, and passes it into the function being tested. This way, I could test many different combinations of recently modified times and thresholds.

During this process, I realized that I had some very tricky functions when it came to testing, and I see the benefits of writing the unit tests as I add features as it might have actually pushed me to modularize the code a lot more into testable parts. One of my output functions is so large that it's pretty much a write off trying to test it. I think I will definitely be keeping testing in mind when I write code from now on, as this was a bit of an eye opener.

Hacktoberfest Recap

Kyle Homen — Sat, 01 Nov 2025 02:55:18 +0000

It was a busy October, and while I didn't reach the Hacktoberfest goal, I did reach my personal goals (and to be honest, the sooner I abandoned Hacktoberfest the better).

The first week, I contributed to the Hiero SDK, which was a beginner friendly issue designed to help newcomers contribute for the first time. This contributing taught me how to follow a CONTRIBUTING.md, and how to set up a GPG key to sign my commits.

The second week, I contributed to 100LinesOfPythonCode, where I wrote a short 100 line text game. This was one that I wish I could do over, as it wasn't something that furthered my goals or gained me any experience, but it allowed me to open up about my interests when I presented my work in class, and I gained useful insight from my professor about what I should be focusing on contributing to.

This is where I abandoned the Hacktoberfest tag and just went rogue, looking for projects on my own that I wanted to contribute to. This actually opened up the field significantly and it took me no time at all to find a brand new project called ShooterCarnival, a grass roots project aiming to create a game using the Godot game engine. This project introduced me to Godot, and the custom programming language used in it called GDScript, which was easy to pick up on as it's very similar to Python. This was my first time contributing to a game project, and the maintainers were excited to have me and gave me a lot of great feedback.

Around this time I had my eye on the wesnoth project, and had found an issue to work on that I spent time with, researching the codebase, learning how to compile the source code into a working game file. By the time I had done all that, someone had swooped in and done the PR, one that had been sitting untouched since August. This one hurt, as it would have been a great addition to my Release 0.2, but I took it on the chin and will hopefully use the knowledge I gained to contribute to wesnoth in the future.

Finally, I turned my focus not to just contributing to a game itself, but the game engine that made it possible. After being introduced to Godot, I went straight to their github to see if there was anything I could do to contribute. Crazy enough, there was thousands of issues open, but nothing labelled for first timers. I just took on the first thing I thought I could help with, and it turned out to be an easy fix, but if it gets merged I'll still feel incredible being able to help contribute to something this cool.

In the end, I walk away from this experience with a renewed confidence, and with an eye on several interesting projects that I plan to continue to contribute to in the future.

Hacktoberfest Week 4

Kyle Homen — Sat, 01 Nov 2025 01:59:38 +0000

This week I decided to try contributing to godot, the game engine I used last week to contribute to the ShooterCarnival project, and a game engine I'm very interested in using for my own projects in the future.

This felt like a very natural progression from where we started, and after I identified in Week 2 that I would like to work on gaming related projects, I took it a step further and contributed to a game engine.

The issue was that when the RichTextLabel gui item added a scrollbar for when the text content overflowed, it wasn't properly removing it when that text content was subsequently removed and shouldn't need the scrollbar anymore.

I looked at the code for a while, tried modifying how the _resize_line and _shape_line functions worked, but nothing was actually changing. I tried removing the scroll_w variable from the equations which -did- make changes in how the text area was being sized, but still did not function correctly. The text area would start with space for the scroll bar, add the scroll bar when needed, then when the scrollbar was removed it would remove that blank space as well.

Finally, I noticed this section of _update_scroll_exceeds:

    if (exceeds != scroll_visible) {
        if (exceeds) {
            scroll_visible = true;
            _prepare_scroll_anchor();
            vscroll->show();
        } else {
            scroll_visible = false;
            scroll_w = 0; // Why are we making this 0?
        }

Whenever we set scroll_visible to false to remove the scroll bar, we're setting the scroll width to 0, which is used to calculate the size of the box. Removing this line resulted in this:

I could be wrong, but compared to the video in the issue and what I was experiencing when I recreated the bug, this looks a lot cleaner and updates correctly when scroll bar is added and removed.

Now.. this ended up being an easy one line fix (unless otherwise stated as my PR is under review), which was not my intention. But it still felt good to pour over the code, work with C++ instead of Python, and contribute something to such a large and respected project.

Hacktoberfest Week 3

Kyle Homen — Tue, 28 Oct 2025 18:36:33 +0000

This week I wanted to contribute to an actual game project repo, with or without the #hacktoberfest tag as that was getting hard to sift through. I had identified wesnoth early on as something I'd like to contribute to when starting this course, so decided to see if they had any good first issues. I found this issue about fixing the sorting of terrain to sort by their translated name and not by the terrain id, which would have been something I could get my feet wet with. I noticed the maintainers didn't typically assign people to issues and usually just replied to people asking to work on an issue by telling them to go ahead and do it, so.. I didn't ask right away. Or at all. The issue had been opened since August, and I needed to figure out how to compile and run the source code to test changes first, so I spent some hours doing that. Once I figured out installing all the dependencies and compiling the game from source, I was ready to make the fix.. tomorrow, I thought. I was on break, there was no rush.

I woke up the next day and saw a PR fixing the issue, filed only a few hours after I had even found the issue. Not gonna lie, that sucked to see. There wasn't anything else that I felt I could contribute to at this time and I had already put in time trying to learn the codebase and compiling the game, so it was a colossal waste of time, at least until something else comes up. This put me down hard, and I put off doing any work until after reading week.

So, I needed to find something else, and it didn't take me long to find Shooter Carnival, which was a fresh community-driven project looking to create a feature-rich 2D shoot-em-up game like Galaga or Gradius. So fresh that I might be the first person outside of the maintainers to contribute some code.

Shooter Carnival is using the open source game engine Godot, which has a lot of similarity to python, so this is a two-pronged opportunity to learn Godot and contribute to a game project. And would you know it, the Godot github has tons and tons of open issues too.. So this doubles? triples? the number of things I'm interested in contributing to. I might have stumbled on something here.

As for the feature I contributed.. it was just setting up the player movement to work in 8 directions using WASD/Arrow keys, while keeping the player movement 'clamped' within the viewport.

extends CharacterBody2D

@export var speed: float = 200.0 # Movement setting

func _physics_process(delta: float) -> void:
    # Get input
    var input_vector := Input.get_vector("move_left", "move_right", "move_up", "move_down")

    # Set velocity based on input
    velocity = input_vector * speed

    # Move player
    move_and_slide()

    # Clamp position
    var screen_rect = get_viewport_rect()
    position.x = clamp(position.x, 0.0, screen_rect.size.x)
    position.y = clamp(position.y, 0.0, screen_rect.size.y)

Yeah I wasn't kidding, the project is fresh!