Just came back to Portugal for the holidays.

It was kind of weird leaving the plane, seeing the blue sky and feeling the Sun's warmth.

The last weeks (maybe months?) in Berlin have been so gray that I kind of forgot how good this feels .

Added some fog, ceiling and sky to my raycaster tests, along with a larger map.

Being able to use Tiled as a map editor really helps for stuff like this.

Sorry for the bad video quality, I think the dark colors really mess up the compression.

Assets used (apart from the ones already mentioned in the previous post):

• https://www.ericteske.com/2014/03/free-creative-commons-moon-photos.htm
• https://opengameart.org/content/grass-texture
• https://opengameart.org/content/dirt-004

This year marks my 3rd winter in Berlin.

When I moved I thought the worst would be the cold weather, but that's actually pretty manageable. The small days are a pain, however (I had no idea about this "winter blues" thing).

It's kind of hard to explain, but I start to feel kind of tired and unmotivated when the days get shorter. I really need to leave the apartment a bit when there's still sun outside (even if the weather sucks).

It's also kind of bizarre how generalized this seems to be - You have a time of the year where people are gloomier than usual and just know that "it's normal, it's the winter".

FWIW, going to the office and to the gym has been helping quite a bit. If you are in a similar situation and have that option, I recommend trying it.

I do usually enjoy working from home, so this has the weird side effect that I actually go to the office more often in the winter when it's cold, raining and snowing than in the summer.

I've been trying to use this year's #adventofcode to learn Zig.

It has been an interesting experience so far. It's nice to work with a lower level language once in a while, and Zig does have some very exciting ideas, such as nice safety features along with it being very easy to ensure some properties about the memory allocations (e.g. no heap allocations).

However, I would lie if I said that I enjoyed the experience. I think the project has a bright future, but the ergonomics are lacking a bit, which is to be expected for a young and less mainstream language (namely regarding documentation, stdlib and compiler error messages).

Maybe some things are just not possible to do but, for example, using iterators in Zig really makes me miss Scala iterators. String parsing has also been a huge pain point.

It's not awful by any means, but personally I would be happy to see Scala Native competing with Zig in performance, so that I could use that instead (biased opinion, I know ).

This weekend I was playing a bit with raycasting.

There's still quite a lot to do, but I think this could already be the base for something. Maybe I'll pick it up once I have more time.

Base assets:

• https://opengameart.org/content/stone-wall-with-cracks
• https://opengameart.org/content/3-crate-textures-w-bump-normal
• https://opengameart.org/content/stone-pavement-ground-tile

I've been posting a lot of my experiences with UIs in Scala lately, but I am also amazed at the amount of people that started experiment with native UIs in Scala recently.

It's really cool to see UIs in Scala going beyond HTML applications.

Here are some amazing examples:

• FxCalculator: An Android App using JavaFX/Gluon/GraalVM
• Scalatromino - Tetris in Scala using Scala Native GTK bindings (Video series)
• Scala Native and SwiftUI
• RogueUI: An UI built on top of Indigo and the Roguelike Starter Kit
• Gooey: Backend agnostic auto derivation of UIs (Scala Days talk)

Playing around with some custom color schemes.

I know this is super cheesy, but I just had to do it (including some post processing effects).

Also, there's something particularly comfy about browsing #Gopher in full screen. Not sure if it's the lack of distracting images or how fast the pages load, but I kind of like it. There's definitely a lack of content, though.

#Scala #UI

I was just playing around with the Gopher protocol and I think I got a new toy project.

This one might take a while to get into a nice state, though (I've been hiding some InterIm/Minart limitations under the rug, and they are quite the problem here). But I think it would be a nice way to validate that InterIm works.

Also, since Gopher is a super simple protocol (it's trivial to implement with raw sockets), I can actually run this in Scala Native with no issues

As promised, here it is!

Späti, a store where you can get all your favorite Coursier packages.

https://github.com/JD557/spaeti

The project is not yet published on the Coursier repo, but you can try it out with cs launch eu.joaocosta:spaeti_3:latest.release -M eu.joaocosta.spaeti.main

Please be aware that this is a very early prototype and will probably have a lot of issues. Use at your own risk.

I've been picking up IterIm again past two weeks (mostly writing some dummy UIs and fixing bugs).

Today I worked on a #UI for Coursier, the #Scala application/artifact manager.

It's nothing too advanced, but I'll give it some more polish and then see if it's worth releasing a demo.

Who knows, maybe someone will find it useful?

Once in a while, I love to play some old-school-style shooters. Levels are usually short and sweet, and there's not much of a story, so even if I stop playing for a while I can pick them back up without any issue.

However, maybe it's my nostalgia goggles, but I'm starting to feel like a lot of the new games in the genre have way too many enemies spawning out of thin air (especially on backtracking is required), which feels kind of boring and uninspired, IMO.

I think it was OK in "Doom (2016)", but "Prodeus" levels are starting to annoy me and I quit "Wrath: Aeon of Ruin" because I couldn't take that anymore (this was during the early access, I think things are a bit more balanced now).

And the thing is, I don't remember Doom, Quake and even DN3D having much of that! It was mostly monster closets, IIRC (which don't annoy me nearly as much). So I wonder where the inspiration for this comes from.

Finally took some time to convert my Neovim config to Lua.

I wouldn't say that it looks much better (a lot of it was just rewriting set foo to vim.opt.foo = true, set g:bar to vim.g.bar = true, ...), but at least it was a nice opportunity to replace some convoluted functions with plugins (because I sure as well wasn't going to port that )

I wanted to play a bit more with transparencies on a more game-like scenario, so I did a very small side scroller demo like a space shooter intro segment where the planet is being destroyed.

I think it turned out quite nice, almost looks like a real game.

Also, I recently played the Europa demo, and that made me really want to do something with a fade to white... I use too much fade to black.

Assets:

• Warped Space Shooter by Ansimuz
• Warped Shooting FC by Ansimuz
• Free Cyberpunk Backgrounds Pixel Art by Craftpix.net

#ScreenshotSaturday

It's been a long time since the original announcement, but I'm quite hyped to see that Retro-bit finally released their Saturn Pro Controller.

Yes, it looks a bit cramped, but I think it's the only controller in the market with 6 face buttons, 4 shoulder buttons and 2 analog sticks (the Duke comes close, but only has 2 shoulder buttons).

This should work pretty well as a controller that works with (almost) all retro games. So even if it's not as comfortable, it still sounds like a great pick.

Sharing in case someone else was also looking for something like this.

Took some time (mostly on the plane) to try follow @ckipp@hachyderm.io 's "An intro to Flow Fields in Scala".

Not exactly the same - I couldn't get my Perlin noise implementation to look good and I added some bloom - but I think it's still in the same spirit.

JS Demo: https://joaocosta.eu/Demos/Flow/

Code: https://gist.github.com/JD557/1ed8e0111313cb77a04d8c77719d3bbd