@vindognz

Hosting move and some small QoL.

So uhh… The old site is gone. I moved the game from Nest to Github Pages: New Link
(The old link shows a “we moved” pages that redirects you)

Nest was sending the 38MB engine file uncompressed and sometimes worked, sometimes took 40+ minutes to send. I tried gzip, i tried brotli, and the proxy just seemed to break it all. Github serves the same game so fast it loads before the splash is done. RIP serve.py.

Okay, onto QoL:
Space to play again. Hit space on the game over screen and you immediately respawn (no more reaching for your mouse every death).

README overhaul. I finally updated it! It has how to play, correct feature list, how it’s built, guidance on running it locally, and the live link. I also dropped the idea of Linux/Windows/Mac downloads, because it’s just easier in a browser.

Still to do: sfx, polish.

HUGE updates, the demo is actually out!

It’s live, and YOU can play the beta right now: Play!
(I will maintain it as the latest, stable build, please comment with any feedback 😊).

The Godot build is exported to WebGL and embedded in a landing page that I built around it.
I tried to keep it somewhat minimal, so it’s just a splash text that fades into a dark ‘cave’ with the same red spikes on the walls, and the game in the middle.

It’s hosted on Nest, being run by a tiny Python server I wrote that gzips everything. Compression might seem excessive, but it shrank the 38MB engine file to ~10MB, so it loads significantly faster. The leaderboard got cooked when publishing, so I had to rewrite some logic but I got it working eventually!

Difficulty used to increase with your score, now we have Levels. Every 10 spikes, the screen clears, a “Level ” banner shows, and the next level starts faster. Danger zones now start at certain levels too, completely ditching the old score driving approach.

I also created a real start screen (This was desperately needed). It has the same firefly background as the game, a little controls hint, and a little demo player hopping spikes :)

All that’s left is sfx, README and polish!

Holy moly I need to remember to devlog 😭

Gameplay has been locked in. Danger zones have been added: at score 10 red columns flash for 3s and insta-kill if you’re in them when time is up. At score 30, two zones spawn at once.

Screen shakes on landing and death. Spike cooldown now scales with score, so the difficulty actually increases. Player is now a squishy jelly ball that deforms on jump, stretches while airborne, and splats on landing with a nice tween animation.

The leaderboard is alive! Input name on first death (cached for the session), auto-submit to Supabase backend, leaderboard is now embedded in the game over screen. Your current run shows golden in the rankings.

Insane visual overhaul. I built a procedural shader for the background that renders 30 animated fireflies (on the GPU). Each one drifts with a unique sine-wave pattern, and pulses brightness. Death burst spawns 12 red sparks that fly outward, and fade out.

To-do: Start screen, audio (jump, death, score sfx), and WebGL export + GitHub Pages.

MY EIGHTH AND (hopefully) FINAL DEVLOG

I THINK WE’RE SHIP READY.

I spent these 3 hours doing a bunch of final polish. The AI now has three difficulty levels to pick from (Easy, Medium and Impossible).

I also added some actual juice to the game. Pieces now make sounds when placed and captured, and buttons make a little click sound. I also added a little rules popup with a tiny board showing how the game works for those who don’t know :)

I finally updated the README from my initial commit too! It now has the full project info, as well as instructions for running FlaskOthello locally.

Everything else was just minor fixes / cleanup. FlaskOthello is officially feature complete.

Time to ship! 🚢

My seventh devloggg

I replaced the AI search that was array based with a full bitboard implementation. This means that the board state is now stored as two 64-bit integers instead of nested lists. We also now have transposition tables and alpha-beta with move ordering based on the TT too!

This was lowkey not THAT much work, but there were SOOOO many bugs to fix. I tried a bunch of ‘optimisations’ that actually made the AI ~27% worse… In the end, we scored a 36% decrease in search time though!

During this time, I did some test deployments to NEST for playtesting with my girlfriend. Turns out, running a Flask dev server in production is a bad idea 💀

I had WebSockets, hints, undo, and UI redesign in my todo list, but decided to scratch those to make sure I ship in time.

Sixth Devlog! (IM LOWKEY REMEMBERING TO DO THESE)

This one was heavy on AI modifications, but I also implemented a replay system! I added transposition tables to the AI, which allows it to reuse positions it has already searched, along with a BUNCH of benchmarking for comparing.

I also changed the AI’s minimax search to make and undo moves in-place instead of constantly creating new OthelloBoard objects which was a BIG optimization.

Now, about that replay system! Games now keep a full move history which allows you to rewatch your game after play. You can jump to the start/end, step through moves one by one, and hold the buttons to scrub through the game.

Lastly, I improve the piece flip animations so captured pieces do a proper flip + many minor bug fixes / refactors.

Fifth devlog! (I KEEP FORGETTING TO DO THESE)

SO much has happened. I added full Player vs CPU support, fixed a major bug where if the AI was black it never made a starting move + a crash from the AI “make a move” loop firing every 1.5s 💀

Draw offers and resignation have been added. For draws, either player can offer and the other can accept/decline, and the AI automatically responds to draw requests based on piece count. Resignation has a confirm dialog to prevent accidents.

Games are now automatically archived when they conclude (read only game copy at /archive/<id> which you’re automatically redirected to if on a stale /game/<id> URL).

I also added piece ‘flip’ animations for the tiles that just got captured, so you can easily tell which tiles have just been captured.

And alongside all this, TONS of refactoring and bug fixes, including extracing common code into resolve_player() and serialize_game() functions, and a strings.js module for game status strings.

Fourth devlog!!

Today I built the actual frontend with a landing page (pick black/white, creates a game and redirects you), a live board page which polls the backend every 1.5s, click to play on legal squares, and CSS of course (green board, yellow legal move outlines).

Previously, when the player had no legal moves, the game would just stop and you’d be stuck. Now, your turn is automatically passed if you have no legal moves.

Added last-move highlighting (red outline on the most recently placed piece, so it’s obvious where your opponent just played) and a proper game-over screen showing the winning colour and final tile count.

Third devlog! (I forgot to devlog…)

I fixed a bunch of serious bugs in the engine (illegal moves overwriting occupied tiles, allowing negative indexing of the board, and more). The minimax now scores wins/loses by token count, not positional advantage at the end of the game, and some documentation cleanup.

I also started working on the Flask backend, which now features 4 API routes for creating and joining games, making your move, and calling for AI moves.

I tested this thoroughly with cURL, so hopefully there aren’t any significant bugs!

My second devlog!

It’s 1:17am right now, but I just finished implementing the most basic minimax algorithm possible, and it (miraculously) works!

I even hacked together a quick CPU vs CPU prototype, and it plays all the way through without any bugs, crashes or other breakage.

Goodnight 💀

First Devlog!

I have a really bad habit of starting 12 projects and never shipping any of them… so I started yet another project!

I loved playing Othello with my brother growing up, but we haven’t been able to play much anymore since I moved to uni. To solve this, I’m developing FlaskOthello in my free time, and I plan to add a minimax algorithm with alpha-beta pruning.

The plan is a Python Flask backend, and a vanilla HTML + CSS + JS frontend, probably hosted on Github Pages.

So far, I’ve made an OthelloBoard class, with a basic board representation, and most of the fundamental game logic (making moves, flipping opponent tiles, validity checks, etc.), and since my COSC class forces me to, I wrote a bunch of doctests out of habit…

Next up: minimax algorithm + alpha-beta pruning!

[Friday, July 17] - Hardware Assembly Complete
Okay so… it’s been a month since my last devlog. I ordered the PCBs June 16th, and they arrived while I was on holiday, but we’re finally back to building!

The PCBs arrived absolutely beautiful. The heart shape clean, and the blue solder mask + white silkscreen looks fabulous.

Soldering was a journey… I got every component on except the battery holder with relative ease (forgot to track the time 🫠). I tested the complete board using an Arduino as a PSU and everything worked perfectly!

There was a lot of residual flux left around the joints (looked like someone sneezed on my board) which I cleaned with an old toothbrush and some hand sanitiser 💀

Next: Solder battery holder, cut the LED legs, then ship!

Big session today! (definitely didn’t forget to write a devlog) Here’s what got shipped:

The game is actually a game now! Spikes spawn from random sides, move across the screen, and despawn off the edge.

Score tracking is in. Each spike that passes the player increments the score, and speed scales with it. Each spike also has a ±50% random deviation in speed, so no two spikes feel the same.

Pixel art is fully gone. Both the player and spike are now drawn entirely in code using Godot’s _draw() API. No image assets, scales perfectly at any zoom (hypothetically).

Global leaderboard is live. Scores submit to a Supabase PostgreSQL backend. We even have a full leaderboard scene with a loading animation and ranked entries.

Game over screen shows your score and lets you play again (reloads the scene, resetting all state for free).

Next up: UI polish, danger zones, and a WebGL export!

I’ve been grinding!

I implemented the basic spike, replaced pixel art with code-drawn vector shapes for smooth edges, and added a very bare bones start screen.

Next up is UI cleanup, score counting, and a game over screen!

First devlog!

So far, I’ve been setting up the base architecture for the game.
Currently I just have a simple square that you can control with WASD, but there are big things ahead!

[Tuesday, Jun 16] - Analog Brightness + PCB Finalized

Firmware is DONE! Got trimpot brightness control working - turn the knob, watch the LED respond beautifully.

Hardware: Rerouted the whole back to fit the trimpot voltage divider properly, added a power switch to toggle it on/off (goodbye battery drain anxiety!). PCB is ready to manufacture!

After many firmware bugs, all three pieces are finally working together: smooth fading firmware + trimpot brightness control + clean power management.

Next: Export Gerbers and ship this to JLCPCB!

[Tuesday, Jun 16] - Smooth fading and PCB polishing.

Firmware: I got the smooth PWM fading working with gamma corrected brightness. The breathing effect is absolutely GORGEOUS and way better than the old blinking.

Hardware: Did some PCB cleaning up. Rescaled the silkscreen text to be bigger and more readable, and repositioned everything to look cleaner on the front.

Both parts are coming together nicely! Firmware is almost done (just need trimpot brightness control), and the PCB design is ready to order soon!

Next up: Integrate analog brightness control from the trimpot.

[Saturday, Jun 6th] - Mode cycling and debouncing.

Core firmware structure updated. Button debouncing is solid (50ms), and mode cycling is working cleanly through OFF, ON and FADE.

Right now, the fade is just blinking, but that’s next on the list. Once I add smooth PWM fading with gamma correction, the breathing effect will be 🤌

Git log (attached) shows my iteration.

We’re getting close to ordering our PCBs!