For the last two days, the CTO of my company has been examining the feasibility of building a videogame as part of a marketing campaign.

To increment the odds, today I built a proof of concept of the idea I proposed him.

Drew lines. Made them stay 1px wide. Had some fun.

Jk, it was a pain in the butt.

In the end, the project settings were the key.

Hope you're all doing well! 🙋‍♂️

It’s going to be a really small project. Its scope is on the dialogue system.

Many games give you diverse dialogue options (e.g. Fallout 1), other try parsing free text (e.g. Event[0]). Either way, the goal is the same: to let you express your in-game feelings through speech.

The thing is: dialogue options are limited, and AIs feel stupid. I’d like to fix that. Hence, I’m now testing a middle ground that should mimic free speech without making one feel blatantly bounded. Let’s see how it goes!

Today, I picked up Dutch leaning after a relatively stale period. To my defense, even though I’ve been productive for most of the time being, my activities didn’t really fit any streak. Instead, they were an effort to make me stick to a routine.

Anyway, I started back from the beginning of the course. It will surely help me get better at the fundamentals while I pick up the pace I lost.

Completed 3 lessons of the “Newcomer - Course 1” course. Reviewed 10 words.

After a long break, I got back on track. Today I watched 40 more minutes of content, split between the usual ElasticSearch course and a new one, called GatsbyJS: Getting Started. I'm not new to GatsbyJS, but skimming through the first two sections of the course vastly helped me to get up to speed with where I left off last time.

Today I filled two pages worth of new idioms and adjectives, from the likes of all thumbs, lumpish, and a turn of the screw.
I also experimented with some creative writing, and bundled all my previous discoveries in a short text 😄

Today I watched 30 more minutes of content. Unfortunately, it looks like the course I set to take is already outdated; many of the commands the instructor showed in today’s demo (and which I so eagerly typed onto my command line) work slightly differently or not at all. This made the whole process painfully more difficult.

Today I researched the meaning of whereby, set to, and jump on. Also, it's the first time Grammarly does not find any issue in a submission I wrote. I guess the hard work of updating Streak Club with several paragraphs of text every day is finally paying off.
Till next time, have a good one!

I jumped on the bandwagon of Elasticsearch, and attended the first few modules of the "Searching and Analyzing Data with Elasticsearch: Getting Started" course by Janani Ravi. She speaks with a heavy Indian accent, but, as long as she's comprehensible, that's fair to me.
Today I watched 41 minutes of content, whereby I get to 2h 45m in total.

In order to get ready for the English Proficiency examination, I've started pinning down all the new idioms, phrasal verbs, and alike which I come across. Written production has always been my weak spot; it's time to remedy.
Today, I've researched and annotated the meaning of "same old same old", "crack on", "front and center", and "foundational".
Let's hope for the best!

Today I completed the fourth and last module of the "Docker Networking" course. The last bit was kind of overwhelming since I had never dealt with docker services before, and they were foundational to most of the explanation.
Anyway, I'm gonna make up for it with the "Docker Deep Dive" course from the same author.
I watched 42m of content, for a total of 2h 1m.

Completed modules 1, 2, and 3 of Nigel Poulton's "Docker Networking" course. In total, I watched 1h 19m of content.

Completed the last lesson of the “Beginner I - Course 1” Babbel course, which figures as my fourth completed course since March 16th. Reviewed around 40 words. It took me twenty minutes.

A couple of days of relaxing have gone by.
Today I set aside the project "hexgrid" and switched to my old pal "geogame". The game currently has no game logic at all, since I'm focusing on the infrastructure first.
As the title suggests, today I laid down the foundation of the go server, which is going to sit between the database and the game client. Most of my effort went into understanding how to structure the project. From that, I then went on and channelized it into a docker image.
Let's see if next time I manage to write some go code and make it do something more thrilling!

Completed 3 more lessons of the “Beginner I - Course 1” Babbel course. Reviewed 44 words. It took me one hour.

Today I went on and got to a point where I instantiate each hexagon independently. Such a feature lets me build the game grid not as a sheet of sprites, but as a grid of objects instead. This ultimately leads to the ability to store the grid data (technically, a level) as a 2d array. Even though serializing the latter is not a priority, now it has become a feasible possibility.
The new tile sprite didn't inspire me enough. Next time I'm gonna think it through and replace it with something different. Till then, good night! 🌖

Completed 2 lessons of the “Beginner I - Course 1” Babbel course. However, today I was more tired than usual, and so I skimmed a lot. Babbel made me review only 4 words this time around. It took me half an hour.

As I expected, sprite-based tiles look a hundred times better than those plain, blurry black lines I had before. The visual style has nothing in common with what I had in mind at the start, but I'm kind of exploring ATM.
Who knows what's gonna come next.

Completed 2 lessons of the “Beginner I - Course 1” Babbel course. I had a lot of fun with the last dialogue. I'm getting the hang of it. Reviewed 26 words. It took me a little bit more than an hour.

Asides from tuning the edge pan velocity, the only thing I did today was scaling down the resolution. The manually drawn grid cells create all sorts of artifacts now, but I'm sure that, as soon as I switch to sprite tiles, everything will look alright.
Tip of the day: you wanna save yourself some headaches? Remember to set imageSmoothingEnabled to false every time you resize the canvas!
That's all for today. Next up: play/pause state; basic tiling.

Completed 2 more lessons of the “Beginner I - Course 1” Babbel course. Reviewed 20 words. It took me one hour.

Unfortunately, it looks like the native drawImage method, which I much-praised last time, also acts as a bottleneck to the whole application. I'll surely need to cut the resolution to a fraction of the window size, probably to a fixed one. On the bright side, that's not a big deal, given how young the project is.
Speaking of bright sides, I've finally got to the point where I move the camera instead of the grid. Borrowing some code from my past self sped that up a lot.
Next up: lower resolution; pause/play states.

Completed 4 lessons of the “Beginner I - Course 1” Babbel course. Reviewed almost 40 words. It took me around a hour.

After careful analysis, I concluded that my old approach to canvas drawing is not outdated at all. Outputting the view to a sub-context first is the way to go. Back in the days, I thought it was a super-duper way of upscaling the game, but it turns out that this cheap trick performs equally well with downscaling matters too. Not only that, but it's also crazy fast to set up and at executing, all thanks to the drawImage method of the CanvasRenderingContext2D, which also accepts an HTMLCanvasElement as the image source.
However, once the sub-canvas gets five times the size of the screen, things start to get laggy. Apparently, 500MB worth of image data is too much for a realtime simulation. I'll someday optimize it.
In the end, I haven't met last time's goal yet, but I'll put it off for today. I guess a good night sleep is more important 😉

To my surprise, I had time today. Hence, I went on and managed to meet the goals I set last time.
Linear edge panning is now a thing, which means that the closer the cursor gets to the edge of the screen, the faster the camera moves. Instead of resorting to fixed steps of ever-narrowing bands, I plugged in a swappable easing function and called it a day.
The zoom got me thinking, though. In my previous experiments, I didn't have to deal with big viewports. All my games used to have a fixed--and pretty low--resolution, so adapting the view to the browser windows size was a matter of drawing to an offscreen canvas, reading its content back, and upscaling it in the process.
This time around, I went for a strange middleware-ish solution where the camera multiplies all the coordinates it receives based on its zoom, but it doesn't thrill me whatsoever. I'll probably revisit it sometime soon.
Anyway, the next milestone is to move the camera instead of the grid, as it is now. I hope I'm gonna make it tomorrow 💪