Hey all!

It’s been two weeks (and a bit) now & it’s time to write a new devlog on what has happened to “Checkmate Simplified”!

By the way, if you missed the last post, go read it, because it explains what “Checkmate Simplified” is & why it exists!

This is going to be another long post, because there are a lot of new and cool features! Either way, let’s get started!

A brand new AI

In the legacy version of Checkmate, the AI wasn’t all that great. It mostly just acted based on single step movement (it didn’t look ahead), which was a real bummer. This was, mainly, due to the complexity of the system.
In standard Chess, you may only move one piece, so the options are fairly limited as to what you can do. However, for legacy Checkmate, this wasn’t the case, as you were allowed to move as much pieces as you wanted at the same time.

In the new Checkmate, you may only move one piece at a time, allowing me to write a proper AI which actually looks ahead and judges things to make the right move!

The way this system works, is based on two things:
1) A scoring system, which can judge a position and give it a score
2) A branching system, which picks the best positions based on their score

The scoring system is simple. You feed the system a grid of tiles with the pieces on there. Each piece gets a unique value, so we know which piece sits where (1 = pawns, 3 = bishop, 5 = rook, etc.). You can pick these values as you want, but this is generally accepted.
To differentiate between teams, we set white pieces as positive numbers, whereas black pieces get negative numbers.

The most simple example to calculate the score, is to simply add up all the numbers in the grid. If both black and white have equal amounts of pieces, the score results to 0. If black has more pieces, the value becomes negative (e.g. -3), and if white has more pieces, the value becomes positive (e.g. +3).
The computer can now use this score to determine whether the scenario is better for him or not. Simply compare the value to the current and see which is the better option. Naturally, this leads to the AI taking pieces wherever possible, as this gives him more “points”.

Next to this, there are a bunch of extra rules, such as:

• How many squares of attacking range does a piece have?

• Is the piece defending another piece?

• Does a piece place check on the enemy king?

• How far from the center is the piece?

I kept it relatively simple for now, but I’ll be adding more rules later on. Actual chess engines can have between 100 and 1000 of these rules!

Now, the branching system. This one is the most complex to program, but the easiest to explain. We start at the scenario we’re currently at (simply put the pieces as they stand on board in a grid, feed it into the system).
From there, we’re going to calculate all possible moves that our pieces have. We then make grids for each of these options and save them as “children” of the first grid. Calculate the score for each of these options, and pick the best 5. Repeat this process for all the 5 children (yielding 25 new options), until you’ve iterated this a set amount of times (“reached an amount of layers”) (in my case, it cuts off at layer=3).

Now, all that’s left to do is check the entire top layer and see which scenario turns out to be the best score for the team playing. Retrace your way back to the “parent” scenario and move the piece that differs in that scenario from the original.

If you didn’t really follow along there, don’t worry, it’s a bit technical. Instead, let’s look at the other features that have been added!

Building logic

One of the things which differentiates Checkmate for normal Chess, is the ability to build stuff. Last time when I posted, I wasn’t all too sure what I was going to do with it, however, I came up with a simple plan.

There are going to be two categories of buildings, each with a set of 3-4 buildings per category (to keep it simple, but varied):
1) Attackers
2) Spawners

The attackers are the easiest & simplest of the two. You place the building somewhere on the edge of the board and it turns some tiles yellow. If any piece (even your own!) steps onto one of these yellow tiles, it gets shot, stabbed or crushed and dies on the spot. These attackers are there to prevent some tiles (mostly near the edges of the board) to be used and can be a very effective way to put some pressure on the enemy or prevent a loss last-minute.

Examples of attackers are the following:

• Crossbow shooting an arrow

• Spiketrap to stab a piece nearby

• Mine to be placed on the field, takes out pieces in a radius

• Catapult to launch a rock into the center of the board

• …

The ideas are pretty much endless and it’s going to require testing and filtering to figure out the most interesting and fun ones to use!

The spawners category is a little more complicated and also not very well defined yet. The idea here is that you can create a building which, over time, turns into a chess piece. You can then move the piece onto the board from any angle.

There is some challenge in this, as it can easily become very overpowered, unless the enemy has some way of “countering” these spawners. This is something I’m still figuring out, but I’m sort of leaning towards allowing building destruction in some way (although this can also become overpowered real quick!).

Ideas I’m having for spawners are the following:

• House which after 3 turns converts into a piece

• Teleporter which swaps any two (selected) pieces around

• Converter which converts a piece into another piece

• Degrader which reverts a piece into a lower state (e.g. rook -> pawn)

• …

The tendancy is to create randomized buildings, where the teleporter swaps any two pieces, or the converter converts the piece into some other piece, however, this ruins the entire point of the strategy in the game.
It’ll take a bit more time before I’ll fully settle on what to do with the buildings, for now, I’ll keep focussing on getting the attackers to work fully.

I’ve also been debating whether I wanted to add a third category, namely “Boosters”, which would give you some kind of advantage (gain more ore, stronger pieces), however, this would massively unbalance the situation & make the player always go for these types of buildings, rather than having the options open for any of them. So, I left them out.

The timer

I’ll try to keep this one short, because the post has been going on for long enough now and this was pretty much a quick shower thought.

Basically, it’s a simple timer integrated into the board, which, once it runs out, automatically skips the turn for you. This adds some depth to the game by pushing you to keep moving and keep thinking.

Don’t worry, though. The amount of time by default will be defined by a lot of playtesting (currently sits at 15 seconds, thinking about moving it to 20 seconds); It will (probably) also become a setting in the future.

Below is an image of the new ‘timer’ mechanic (at 2x speed):

Little other things

I’ve adjusted some other things aswell, such as the piece movement, which has been changed from ‘click piece -> click tile to move to’ into ‘click & drag to tile’.

This is much smoother and feels a lot better in comparision to the old system. It feels like you’re really moving the piece around on the board!

Finally, something that I want to include in the future, is randomized startup layouts. This is something I’ll be working on for next week and it boils down to a set of 10-12 different piece location layouts. These layouts define where some pieces can go, then places a random piece at each of the points in the layout, creating a random start every single time you play.

The randomization is really important, as it makes for a fun experience every single time and it makes sure that you win based on skill and planning, rather than on predefined knowlegde or luck.
Obviously, both white and black will start with the same team layout.

Final words

Phew! It’s been quite the article!

Thanks for sticking along and reading all the way through! I do really appreciate it! - Let me know if you have any building ideas, I’m currently open for any suggestion (even if it sounds like a dumb idea to you!).

I’ll keep working on the game, polishing the features as I go. Currently on the schedule is to create a couple of buildings for both categories, seperate them out and make them functional. Then, I’ll add the randomized start pattern. From there, I can start playtesting a bit, tweak some things and if it’s to my liking, I’ll pack it into an executable, allowing for it to be played by other people in order to gather more feedback.

That’s all from me for now!

Have a great day and I’ll catch y’all later!