Chess 60, an incorrect name

It occurred to me that I had improperly counted the amount of possible starting combinations of the so-called “Chess 60”. I had overlooked that there are two knights, and so many of the positions will simply be repeats of another, but with Knight A and Knight B flipping positions. So is it true that we can simply halve the amount of positions, and start calling the game Chess 30? Perhaps not.

Here we have a chess board, set up with the classical chess starting position.


The classic chess starting position

Continue reading

Posted in Chess, Chess 60, Game Design | Tagged , , | Leave a comment

Testing programming syntax

I’ve struggled when posting programming posts, since WordPress has always improperly formatted them. This is quite unfortunate, since poor formatting can ruin the readability of a post. Luckily, when researching CGI extensions for WordPress (which hopefully allows me to run c++ on WordPress) I stumbled upon a post that claimed I could have proper syntax for programming with just a few lines added into the post. So here goes:

void SetUpSprite(Sprite* sprite, std::string textureName)
GLuint VBO;
GLfloat vertices[]={
// Positions // Texture Coords
0.0f, 1.0f, 0.0f, 1.0f,
1.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 0.0f, 0.0f,

0.0f, 1.0f, 0.0f, 1.0f,
1.0f, 1.0f, 1.0f, 1.0f,
1.0f, 0.0f, 1.0f, 0.0f

glGenVertexArrays(1, &sprite->quadVAO);
glGenBuffers(1, &VBO);

glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

//send position and Tex as one vec4
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 4*sizeof(GLfloat), (GLvoid*)0);

glBindVertexArray(0); //unbind VAO
glBindBuffer(GL_ARRAY_BUFFER, 0); //Unbind VBO

//Load texture and store texture ID.

The above is some graphics code I had in my game. Seems to look pretty good to me.

Edit: However that last line is a nightmare. It’s supposed to look like this:


Let me try that again


Weirdly it now works. This is an odd bug, but I still feel that this is a useful feature.

Posted in Uncategorized | Leave a comment

Chess 60 – Graphical Display

This is a follow up from my previous post, please read that first. Thank you.

Since a command line program isn’t particularly interesting I decided to turn that small program that generates a board into a program that also displays that board. Without much further ado, here’s a screenshot.


Yes of course it is very ugly, that’s not the point, it can easily be beautified. The eventual goal with this is to create a website that generates boards for players, similar to That way I simply need a phone and a chess board to set up my board.

Posted in Chess 60, Game Design | Leave a comment

Chess 60

Recently I’ve gotten heavily into chess, and while I think it’s a great game, I feel that it has one flaw: if you want to be good, you have to do a lot of rote memorization of openings. The fun of chess comes from setting up tactics and positions, and when I was first starting out, I had a great deal of enjoyment right from move 1, since I was trying to calculate out all the different moves and not leave pieces hanging. Basically I was playing chess right from move 1.

Unfortunately, once you’ve played a few hundred games the game effectively starts later. This is because in any position in chess, there are often only a few valid moves. If that position is at move 20 of the game, it’s up to you to find them. If that position happens at move 5 of the game, tons of players have already gotten there, and you’re expected to know a very strong move in response to whatever your opponent has done. It makes the game quite boring, since I’m just making the moves that other people have told me to make. Even more, both my opponent and I are making very strong moves, which means that it is quite difficult to win or lose games quickly.

This is quite unfortunate, and, as luck would have it, lots of people agree with me. This has lead people to create two variants of chess, shuffle chess, and chess 960 (otherwise known as Fischer Chess). Shuffle chess is where the pieces on the back rand are entirely randomized. This has some problems, namely being that you can’t castle in shuffle chess. Furthermore, not being guaranteed one light and dark squared bishop can change the game far too much, and make it feel not like chess. Bobby Fischer, the former world champion, invented a version of random chess where the pieces on the back row are randomized, however, the players are guaranteed one light square bishop and one dark square bishop. Additionally, each player can castle long or short, as long as there are no pieces in the way.

Frankly I don’t love chess 960, because I feel it still changes the game too much. I feel it’s confusing for newcomers to castle when the king and rooks are totally out of their normal positions. That’s why I decided to make a version where the king and rooks stay in their classical positions. Each player gets one light square and dark square bishop, but aside from that the back row is randomized.

Doing the calculations, it turns out that there are 60 possible variations that can arise from those rules. For those wondering how I got there, there are 5 “available” slots for the moveable pieces to go (2 bishops, 2 knights, and the queen). 5! = 5x4x3x2x1=120. However, half of those positions will be invalid, since they will have two dark square, or two light square bishops. That leaves us with 60 positions, which is still easily enough variation that it destroys any opening preparation, and leaves the players to start playing again from move 1.

This also sidesteps the problem that chess 960 has, where some positions are simply unbalanced, and heavily favour white. In other words, it’s not really chess 960 because you have to throw away a lot of junk starting positions. Classical chess has a very well balanced board, which gives winning chances to both sides. It also gives plenty of tactics to both sides. Chess 60 (my version) gives a true 60 positions, since the limitations (king in the middle, rooks at the end) provide enough structure that (I believe) all 60 positions are valid for high level competitive play. Of course, I can’t really claim that without having a GM take a look at all the positions, and not just that but actually play them, but I believe my point remains.

Since I had better put this programming education to use, I wrote a small (129 line) program in c++ that generates a board, and then prints out that board in text. It took less than 2 hours from the first line of code to the finished product. And at the end, for the ultimate irony: the very first board it printed out, was classical chess.

Posted in Uncategorized | Leave a comment


A few posts back I was writing about things that I’ll change for the next game that I make. One of those was the increased use of structs, especially if there is a lot of repeated code. Today and yesterday I spent my time creating the new project of Dangerous Games. In doing so, I decided that I was going to create a struct called CharacterBase, which stored a bunch of variables that every character (PC and NPC) must have. CharacterBase looks like:

struct CharacterBase{
float xVel, yVel;
tdcRct clBx;
SDL_Rect rBx;
float angle;
float hlth;
bool isAlv, isSpwn;

Since WordPress always makes things very awkward to indent, I fully expect this to look weird. Anyway, I realized that all characters share velocity, collision box, rendering box, angle facing, health, and flags for being alive and being spawned. Not every character needs all of this, but even the ones that don’t need 90% of this.

Putting this all in one struct has a few benefits. The first is that I can make a change to the CharacterBase struct, and I don’t have to make that exact same change to all the NPC’s. Secondly, it saves a bunch of vertical space to give each NPC an array of these instead of each item individually. Thirdly, if I wanted to, I could create one constructor-like function, and just pass in this struct for each NPC and all of this information would be initialized to default values. Fourthly, it makes the code easier to read, since we can easily understand something that every character has, without having it burden the individual structs. Fifthly, somewhat on the same point, we can easily look at the individual character structs to see what is unique about this character.

Continue reading

Posted in Dangerous Games, Programming | Tagged , , , , , , , | Leave a comment

Games are objective, players aren’t

So I made the claim that games are about 95% objective, and here’s why that doesn’t mean that games should get a single score when reviewed. We don’t really appreciate games objectively, we each value the different aspects of games with different priorities.

If I play a Japanese RPG, there’s going to be a very good chance that I’ll hate it. It may very well be an absolutely accurate score by me if I give the game a 3/10, whatever that means. On the other hand, someone else might love that same game, and give it a 9/10. When I point out that this game has little to no depth in its combat, what you spend the majority of the game doing, they counter by claiming that they like the character they play as. When I point out that the world is so obviously created for the player (poor dynamism, consistency, inconsistent tone), they agree but say that the game gives them lots of freedom to do whatever they would like, and they like that the game makes them the center of attention.

Continue reading

Posted in Game Criticism | Tagged , , | Leave a comment

Tying it all together – what makes games good

This post can be thought of as the collection of all the conclusions from my previous posts. In other words, it’s not so much what makes games good, as it is advise for how to make good games. My goal is that reading this post benefits you as a designer. Some of these are going to be brief, and there’s a reason why I felt the need to write >10,000 words previously. But without much further ado:

Continue reading

Posted in Game Design | Leave a comment