There are a few collections around like: https://github.com/adi1090x/rofi

These things tend to imply dependencies for how they're implemented plus whatever they are integrating. The UX is definitely the right one tho! Rofi is great for working on custom dev tools - you can pass lines in as stdin, it sends back the selected item on stdout, then you exec the matching output command.

I started a project called 'ralphie' to do this with babashka a couple years ago, but later i absorbed that into a monorepo called clawe - you can see the rofi namespace here: https://github.com/russmatney/clawe/blob/3987390ffe538d878045e9d886190542fb111b9e/src/ralphie/rofi.clj#L146-L156

streets of rage 2!

Another much shorter answer is, once you pay the steam fee, you can easily play your game on the Steam Deck, so it helps a ton for playtesting (both myself and putting the games in people's hands).

And otherwise, the Dino page is up now in the hopes of starting to collect wishlists sooner than later.

Excellent! Let me know if you have any questions!

I’m working on some devlogs that will share parts of the implementation - I’m happy to dig into whatever directions are useful

https://godotwildjam.com runs every month for the last …60+ months?! Feels like a long time!

Anyway, It’s a great community of godot game devs!

This was a cool talk on teaching programming gradually (with a lang called hedy) at last year’s strangeloop: https://youtu.be/fmF7HpU_-9k - might be some useful takeaways for you in there

Interesting, syncing history across machines is pretty cool. While writing this I went looking for my yabai logs helper as an example, but of course, it's on my other machine, haha

Security (sharing secrets from that history) comes to mind, so I feel compelled to mention that adding a space before a command is a pattern for preventing it from being stored in history, though I think I had to opt-in to that in my zsh config: setopt HIST_IGNORE_SPACE

Nice work!

Tauri is great. I haven't built a proper app with the nice native backend features, but i wrote a wrapper for passing a url on the command line, which lets you run an arbitrary web app like it's a native one: https://github.com/russmatney/clove

Very happy to have something lightweight!

These are great! It's cool to get a feel for which instance the community is from at a glance

Cool! Thanks for open-sourcing it!

Makes me think maybe the fediverse jam could be a place to build fediverse-tools, not just games - or maybe there's a different opportunity for building fedi-tools similar to the Godot Addons Jam

reminds me of https://github.com/a-little-org-called-mario/a-little-game-called-mario

I don't think it's that crazy - and it'd be fun to collaborate on something low-key, and maybe it grows into something?

Indeed! I pulled a few below (too many?) from my current project, Dino, which is on github if you want to dig into more.

Some of these make use of custom autoloads, but should still show the idea. Note the use of bind in places as well, which is making use of the same func/callable improvements.

• Inlining a setup_fn to be called on the player after they're respawned:

func on_player_died(_player):
  Game.respawn_player.call_deferred({setup_fn=func(p):
    Hotel.check_in(p, {health=p.initial_health})})

• Inlining a hide_fn predicate in a list of data (these dictionaries eventually get mapped into buttons)

var menu_scenes = [
  {label="Start Game", fn=Game.restart_game.bind(SuperElevatorLevel)},
  {label="Dino Menu", fn=Navi.nav_to_main_menu,
   hide_fn=func(): return not (OS.has_feature("dino") or OS.has_feature("editor")),
}]

• Gathering a list of resource_paths from a list of levels:

var level_paths = levels.map(func(l): return l.resource_path)

• A basic inline connect:

player.ready.connect(func(): player_ready.emit(player))

• A more interesting connect:

func on_player_spawned(player):
  player.died.connect(on_player_died.bind(player), CONNECT_ONE_SHOT)

• Creating a bunch of actions that use predicates heavily:

I have a general actions system, so it's nice to be able to implement small functions to describe some behavior rather than create a fully named function for every piece of logic.

var actions = [
  Action.mk({label="Open", fn=open_door,
    source_can_execute=func(): return state == door_state.CLOSED}),
  Action.mk({label="Close", fn=close_door,
    source_can_execute=func(): return state == door_state.OPEN}),
  Action.mk({label="Unlock", fn=unlock_door,
    source_can_execute=func(): return state == door_state.LOCKED,
    actor_can_execute=func(actor):
    if actor.has_method("can_unlock_door"):
      return actor.can_unlock_door()
    }),
  Action.mk({label="Jostle", fn=jostle_door,
    source_can_execute=func(): return state == door_state.LOCKED,
    actor_can_execute=func(actor):
    if actor.has_method("can_unlock_door"):
      return not actor.can_unlock_door()
    return true
    })
  ]