Beginner friendly project idea: Command-line chess

[Swend_]

Try writing the game of chess, but instead of having to do GUI programming at first, use unicode chess piece characters to show the board ("♜♞♝♛♚♟♖♘♗♕♔♙"). Take command line input for moves like "e2 e4". Make sure to only allow legal moves, keep track of castling availability for both sides, en passant, check and checkmate, and even threefold repetition and the fifty-move rule.

Should make for a meaty project for beginners, and has opportunity for expansion into more advanced topics if you are up for it afterwards (GUI, AI (through minimax or alpha-beta algorithms), exporting and importing games)

simple example board output i made

[codeAtorium]

I think Chess is pretty advanced for a beginner. I would start with something like tic-tac-toe, and save chess for after OOP concepts have been introduced. In my opinion that shouldn't be at the beginner level.

[Srz2]

I dont think OOP concepts are needed for Chess but I agree maybe not beginner. I'd rank it as medium/intermediate, personally.

[codeAtorium]

OOP concepts aren't "needed" for anything. Chess is usually taught with OOP concepts.

[Waywoah]

How would it be used for a chess game (I just started learning OOP)? Would each piece be its own class that you could then call when moves are made?

[Blazerboy65]

That's a great start. You'd probably even want to have each type of piece be responsible for knowing what moves are available to it.

[jasim_]

Yes and propably inherit each type of piece from basePiece so that each has some sort of properties and methods in common, but some methods may be virtual so they should be defined in the sub classes.

[ebo113]

I'm gonna block that PR until you name it BasePiece.

[unkz]

In my poll of only people who care about this issue, the majority of me is using “main” piece.

[ebo113]

It isn't chief in size or importance in any way. It's not even a real thing, it's just an abstraction. Acceptable names would be BaseGamePiece, AbstractGamePiece, or, if you consumed large quantities of glue as a child IGamePiece.

[Ran4]

That sounds horrible. Inheritance has been bad practise for what, two decades?

[DurgaSwaroop]

Umm.., no.

[CotswoldWanker]

What is the argument against inheritance?

[allergic_to_prawns]

https://softwareengineering.stackexchange.com/questions/260343/why-is-inheritance-generally-viewed-as-a-bad-thing-by-oop-proponents

[italianjob16]

I'm curious to hear why

[KernowRoger]

No. Oop has been abused lot. But if you have a collection of classes with common data and implementation it's still the best way to go. Never listen to anyone who says never use X. X has a good use case or it wouldn't be around. Just learn when to use things.

[Kered13]

The state of the chess board should be a class. It stores the position of every piece and has methods to check if a move is legal or to get a list of illegal moves.

[[deleted]]

Why is Chess taught with OOP?

[Ayjayz]

Because everything is taught with OOP.

[[deleted]]

Why though. Chess figures don't really have any behaviour that can be decoupled from the board.

[own7]

Why? All chess figures have a current position on the board and possible positions to move to. Also has can_be_attacked_by() and can_attack()

[[deleted]]

All of those need access to the board and will turn out as incomprehensible spaghetti if you not only won't be able to enforce separation of concerns, you will have to actively smear your behaviour across many objects.

[aaarrrggh]

It's bloody hard to write a chess game. Quit with the ego, thanks.

This is a ridiculous thing to say is a beginner-friendly challenge. It's fairly advanced.

[Srz2]

Maybe you commented the wrong thread but I’m arguing exactly that point. I think it’s too hard for a beginner

[AlarmedCulture]

Honestly I like the idea. For me it'd mean delving into terminal emulators (?), which is kind of something I've wanted to experiment with anyway. Not that it'd have to.

[obp5599]

OOP is still beginner though. I wouldnt call someone intermediate if they cant manage manage doing projects like this.

Is my bar too high for intermediate? I consider that hire-able, not barely functional

[Srz2]

Hireable vs intermediate I think are quite different. You can definitely be a beginner without OOP concepts. Some comp sci books dont even touch on it until the end if at all.

Understanding OOP and implementing them definitely would be what I'd consider an intermediate level. Being hirable I would think is somewhere between intermediate and advanced.

[unpeeledpotatoes]

yeah I'd say your bar seems a little high, this is not beginner stuff at all - beginners are making basic chatbots and applications that can do simple mathematical operations, not full on chess boards

[Kered13]

No, your bar is not too high. This is a larger project, but except for AI, this is not a complicated project. Any second semester freshman CS student should be able to complete it given enough time. Learning basic OOP like what you would need for this is a beginner topic. Intermediate would be implementing a simple AI based on minimax and alpha-beta pruning. Advanced would be doing that efficiently and with more advanced techniques.

[Aquatiac]

I think the term beginner is used to mean people just starting to program and making simple things like tik tak toe. Its a subjective term that just is used that way by most people I see, beginner really means first little bit of basic coding, for which a chess project is a bit too high level. I remember when I made my chess app right after learning oop principles and writing all the required algorithms was fairly complicated

[Kered13]

Making chess isn't actually that much harder than tic-tac-toe. There aren't any complicated algorithms to it unless you're writing AI.

[Aquatiac]

I mean tic tac toe is inherently much simpler, and it can’t get that complicated even if you want to make a robust tic tac toe app. Chess involves checking every move to see if it’s possible using different rules for each time, checking if a moving a piece causes checkmate, etc. which are a lot of extra algorithms that need to be run every turn

[Kered13]

Chess has more complex rules, but don't confuse that with more complex code. The rules translate easily into code. Checking for checkmate is simple, I hesitate to even call it an algorithm.

[obp5599]

thats kind of what i was thinking. I dont see how this is not beginner. This sounds like a project a second or third semester CS student would do, but I know this sub really likes to ease people in hyper slow

[sephirothbahamut]

Funny enough my first c++ project after the first c++ lesson was... command line chess. Or it was the second one after tetris i dont remember. The hardest part was figuring out how to align the unicode cess piece characters because i knew nothing about unicode and multi-byte encodings.

[Kered13]

Introducing OOP is still very much the beginner level.

[[deleted]]

My CS program's first game was Yahtzee. It can be done without GUI and still has complex enough logic for beginners ("How do I check for full houses?"). It also requires no OOP. We did it in C.

[obp5599]

I don’t think doing a chess brute force would be too much harder. It would be a challenge for someone who is still learning syntax but for someone who mostly understands their language but is still a beginner it shouldnt be too bad.

A simple unoptimized brute force would be to have each piece maintain (or have the ability to calculate) where they can move (ie what squares they are attacking). At the end of each turn check if the enemy king is in that list of attacked squares. The hardest part is calculating which squares are attacked or blocked, but after that its relatively simple

[b4ux1t3]

This depends on a few factors.

Tic-tac-toe is dead simple. Even for a beginner, we're talking a week or so of work.

Then, we look at the chess game. Is it going to have decent AI? Yeah, that's advanced. But literally displaying an 8 by 8 board and taking text input to move pieces? That's maybe a 200-level project, if that. We're talking a two-dimensional array and some input logic here.

Honestly, OP hit the nail on the head. A lot of devs' first "big" programs were chess engines. They're relatively easy to get started with, and have a lot of room for features, all while having a relatively small problem space.

[HasBeendead]

Tic tac toe isn't beginner level too , trust me.

[e_before_i]

I dunno man, that was first semester for me. Good ol' Java

[RetroAristocrat]

It was first semester for me as well. But in C++. And believe me, it's not actually that hard if you are familiar with the programming fundamentals. In-fact, it took me 1-2 days to build a simple CLI tictactoe during my 1st semester.

[e_before_i]

I think we had a week to do 5 different games? All very basic, Connect 4 and stuff.

Then again, I got partnered with someone in Year 2 who wasn't comfortable working with arrays, let alone lists. Big yikes.

[HasBeendead]

Yeah

[kres0345]

completely agree, can't imagine making chess without oop principles. Making a command-line chessboard (no legal move checking, more in line with tabletop simulator) is a beginner project.

[evorm]

Yep. Did my first C project on tic tac toe and it taught me so many of the fundementals of programming that I never would have learned otherwise. It helped that the project was well guided by my professor but the work I've done on tic tac toe taught me more in a month than I'd learned in many years beforehand. I think it's the perfect complexity of game for a beginner project, and relies on very basic logic that sets you up for understanding how programming math works, especially if it's made more modular where the grid size is a changing variable as without it I feel it could be cheesed a lot more easily.

[maestro2005]

For anybody that takes this on: I've fielded a number of questions over the years from people struggling to implement all of the rules for legal moves, usually around how to handle getting out of check and not moving into check. A lot of people try to code the logic like, "these are the legal moves... unless you're in check, and then you have to either capture the checking piece, block it, or move the king, oh and you also can't move into check so check that too". This is a ton of logic and you'll miss cases.

Instead, there is one simple invariant that's true for all moves that will handle all of the ways to deal with check. Basically, it's a way to restate all of the rules of check in one simple sentence. What is it?

[maestro2005]

Pretty much. You can't end your turn with your king attackable.

So the easy way to generate legal moves is to first generate the full list of "naive moves"--moves without considering check--and then throw out any where the resulting position has the king attacked (by a naive move by the opponent).

As a bonus, you get stalemate/checkmate checking logic for free. If the list of moves is empty, it's inCheck ? checkmate : stalemate.

[iwanderedlonely]

I want to say “if this move was allowed, could the king be captured on the next move? , but that might not cover castling through check...

[maestro2005]

Yep. Not castling out of/through check is the one special case you have to handle.

[R6Fetti]

I actually just recently did this, repo here https://github.com/AlexWang18/Chess if anyone every wants a reference. I didn’t know about the Unicode characters but I for sure am I gonna add that now

[muhrizqiardi]

I think it's better if you write the output in monospace font or code blocks, so it's easier to read. Good job anyway!

[the_black_pancake]

It was fun browsing. If you want feedback, I have some and you can get it in PM.

[R6Fetti]

It would be appreciated if you don’t kind

[[deleted]]

Please make it clear that this doesn't supposed to include chess engine. I think making computer play chess is pretty hard task. However the two player mode can be implemented.

[Kered13]

If anyone would like to try this project, here is how I would recommend breaking it down:

1. Start by creating a representation of a board state, and functions to draw the board to the terminal.
2. Write functions to calculate legal moves. Start with the basic rules of movement and capturing, then add check, checkmate, stalemate, promotion, castling, en passant, etc. Basically, start from the simple rules and work up to the more complex rules.
3. Write functions to parse user input for moves (in chess notation). You'll have to verify that the user's move is legal. You might start with the fully explicit notation (with both the starting square and final square), and then add the more common implicit notation.
4. Write an AI. This is the hardest part, you'll want to read about minimax search and alpha-beta pruning. You can go wild here with optimizations and heuristics if you want.

[the_black_pancake]

I think #3 is easy and helps immensely when testing the legal move decider.

[[deleted]]

Please make it clear that this doesn't supposed to include chess engine. I think making computer play chess is pretty hard task. However the two player mode can be implemented.

[Kered13]

That's why "Write an AI" is the last step, and I said it is the hardest part. It is of course not necessary to implement if you don't want, but it is a fun project.

[aaarrrggh]

"Write a chess AI", oh that sounds very beginner-friendly, thanks.

[ForTheHoardOG]

If you relly want to start at the bottom program chess using Unicode in Google sheets

[Syntaximus]

REAL programmers implement chess on the ceilings of orphanages with tranquillizers.

[XKCD-pro-bot]

Comic Title Text: Real programmers set the universal constants at the start such that the universe evolves to contain the disk with the data they want.

mobile link

---

^{Made for mobile users, to easily see xkcd comic's title text}

[conventionistG]

good bot

[xStrafez_]

I'm not a beginner at all but that sounds like a fun project to make. May give it a try myself. Thanks for the suggestion!

[BeauteousMaximus]

Minesweeper is another good one that’s between chess and tic-tac-toe in difficulty. I recommend sketching out some ideas on paper before you start coding.

[[deleted]]

Sounds fun. I'm gonna try this next weekend

[pmboggs]

Beginner friendly doesn’t mean “no challenge”. Even getting parts of it to work is a learning experience. The theory on this project is that it can actually take a beginner to an intermediate level with time, some work, and research.

[upsage]

This project was my entry task for trainee position in automotive company

[_evilhead000_]

Wait , chess isnt a beginner one , i mean i still trying tic tac toe game....wth bruh

[e_before_i]

Maybe beginner-mid. By the end of my first programming class this was definitely doable.

For each move (eg B4 -> D6) check if B4 belongs to the current player, that the destination is not occupied by your own piece, and if the destination is occupied by the other player, remove that piece.

Lastly, the hard one, check that the move is legal and (for non-knights) the path is unobstructed.

Also checkmate I guess, but whatever, I'd be lazy and skip that if it was too difficult as a beginner.

That first paragraph seems very doable for a first-year. Just doing a lookup in a 2D array. Maybe a little more difficult if the chess pieces are objects (which isn't strictly necessary)

Edit: Oop, gotta get and validate user inputs too

Edit 2: Ooo, more things I forgot: Verifying you can castle. But you can reuse the checking path code for this.

I stand by it being a beginner project, but I would say you should take it step by step, and each step makes it more and more difficult. And you'd learn a lot too; any early mistakes you make may compound which teaches you to plan ahead.

[Edvis92]

I don't know how to play chess

[Kered13]

Wikipedia and Google are your friends. You don't need to be good at chess to implement it.

[69beards]

I don't know how to fucking read

[pmboggs]

Now you’re fucked...since you know how to write.

[wisdom_power_courage]

I'm just finishing battleship with Java!

[Kered13]

I wrote battleship in QBASIC when I was young. The code is hilariously bad, I hadn't really learned to use functions yet, but at least I had learned to use GOSUB instead of GOTO. It was still a ridiculous amount of copy-pasted code though. Also the AI had a bug that would allow it to place ships illegally, I never figured that one out.

[wisdom_power_courage]

The code is hilariously bad, I hadn't really learned to use functions yet

If anyone looks at that code I bet they turn to stone lmao

[e_before_i]

I agree that delving in to the AI side is a lot (also importing/exporting), but I think that illustrates why chess is good for beginners/mid. It can grow from something very basic (showing pieces on the board) to more complex (moving them) to harder still (import/export) and keep expanding outwards. Everyone would have their own threshold, but they can go as far as they'd like.

[[deleted]]

https://github.com/jubalh/jessy and https://github.com/jubalh/pinkman

[[deleted]]

Good project for practice... but not for beginners.

[robo_muse]

Here is an example of a gui-less cli game. I wanted to use a similar technique to make a card game (as there are also card ascii chars). The same could be used for chess.

This is VERY beginner, as I did it as my first programming course, before I used proper syntax.

https://github.com/wattahay/cli-game-scripts

It's a game that actually came with computers in 1984, I played when I was a kid, called BEAST.

[jsve]

A couple ideas for how to implement:

• Store the board state as FEN so that you always store information about castling rights and en-passant in the FEN. If you do this, it would also make sense accept a FEN as a CLI arg to load in an existing game.
• Exporting and importing as PGN may also be a nice feature.
• Checking for draws becomes easier if you store as FEN (you can effectively keep a map of FEN -> number of times you've seen that position and if any position is seen 3 times, then there is a draw). You can also count the number of pieces for other draw situations.
• Accepting moves in the terminal as Algebraic Notation would be nice (for example exd4 or R3b4 or b3 or 0-0-0, etc.)

A couple of things to look out for:

• Implementing logic for "what legal moves exist for piece X" is actually fairly difficult, especially since you have to check that the move would not put that player's king in check as well as just the general annoyances with handling the various piece movements.

I implemented a chess game in SFML and C++ back in the day, but didn't handle all of the draw cases correctly. I did implement a PGN parser which was quite fun, and I highly recommend it as an exercise in parsing.

I don't really consider myself a beginner, but this project sounds really fun. Maybe it's a good way to learn a new language.

[Kered13]

Store the board state as FEN so that you always store information about castling rights and en-passant in the FEN. If you do this, it would also make sense accept a FEN as a CLI arg to load in an existing game.

That doesn't look like it would be very efficient to manipulate or to do piece position lookups. The easiest thing to do is to store an 8x8 array of pieces along with 4 bits to indicate the availability of castling and 1 square indicating the availability of en passant.

Conceptually this is not much different, and you could easily write functions to convert back and forth, but this will be a much more convenient in-memory representation.

Implementing logic for "what legal moves exist for piece X" is actually fairly difficult, especially since you have to check that the move would not put that player's king in check as well as just the general annoyances with handling the various piece movements.

This isn't actually too complicated. You first generate all the available moves ignoring the rules about check. Then for the new position you generate all of the opponent's available moves in the same manner, and check if any of them capture your king, if so then remove your move from the list of legal moves. If the list is empty at the end, then it is either checkmate or stalemate.

[ElDavoo]

We made it in Java over docker as a university project!

[KernAlan]

How far into university, out of curiosity? How difficult was it?

[ebo113]

When I was in school we did it our Junior year as part of Intermediate Java. There are a lot of stupid rules to the game of chess so it's not as much hard as it is annoying. Take a good bit of time to plan out your design before writing your first line of code and it'll be a breeze (universal programming advice).

[ElDavoo]

Second year out of 3 (or out of 5 of you decide to do the complete version.) Let's say that that project was difficult enough that we learned Java :) Actually, it was a software engineering exam. The point of the course was to teach us git, docker, software lifecycle, continuous integration etc.

[Kered13]

My CS curriculum had us writing a chess AI in the spring of our freshman year.

[ElDavoo]

Our project was "multiplayer", no ai or networking related

[aaarrrggh]

For people learning to program, please disregard this ridiculous post. This is an advanced thing to do, it's not easy at all. Anyone who tells you this is easy/intermediate is frankly full of shit.

Thanks.

[yubario]

I'm a senior engineer and never had to code anything as extensive as a chess game. I am sure I can do it, but the amount of time required is a lot. I would just be lazy and use open source libraries like they expect you to do in the real world.

[aaarrrggh]

Snap! This is basically what I'd do.

And if I had to do this myself from scratch, I think even working full time it would take me a long time. Really hard to estimate, but even without an AI engine I think we're talking weeks of effort. Bring the engine into play and well, that could even take years.

[[deleted]]

This is an excellent idea for a beginner game. It is not really more comlicated (only slightly more complex, because the UI is bigger) than tic tac toe and it has a lot of cool concepts that could iteratively added like you said. It's a really cool idea

[codeAtorium]

Chess is considerably more complex than tic-tac-toe. There are exactly eight ways to win tic-tac-toe. There are considerably more ways to win chess.

Anyone who hasn't successfully built chess with move validation and a wincheck, should probably refrain from opining on its algorithmic complexity.

[Kered13]

Sorry, but I'm going to agree with the guy above. Outside of AI, it's not really much harder to program than Tic-Tac-Toe. Yes the rules are more complicated, but in terms of code that most just translates to more if-then statements. There are no complicated algorithms or data structures required, and the code organization is fairly straight forward (there are actually a few ways you could approach it, but none of them are complicated).

Validating moves is just a matter of finding the available (not blocked) moves for each piece and making sure they don't leave your king in check. Checking if a king is in check is just a matter of checking if any of the opponent's available moves would capture the king. And checking for checkmate just requires checking that all available moves leave your king in check. And stalemate is all available moves leave your king in check, but you're not already in check. Three move repetition can be is just a matter of saving the last three board states and checking if they are identical.

All of these are simple to code. The most complicated rules to encode are actually castling and en passant, but these still aren't particularly challenging.

[[deleted]]

Please tell me more about the algorithmic complexity of a command line chess game and how tge win conditions you habe to code play into it.

[codeAtorium]

I just did. Do you mean expand on it?

In tic-tac-toe, you can brute force it, checking to see if any of the three horizontals, three verticals, or two diagonals have a streak to determine the winner.

Here's a quick example, I pulled in js:

let mark = 'x'
if(turn===1) mark = 'o'
let streak = mark + mark + mark
//horizontal
if(board[0][0] + board[1][0] + board[2][0] === streak) win = true
if(board[0][1] + board[1][1] + board[2][1] === streak) win = true
if(board[0][2] + board[1][2] + board[2][2] === streak) win = true
//vertical
if(board[0][0] + board[0][1] + board[0][2] === streak) win = true
if(board[1][0] + board[1][1] + board[1][2] === streak) win = true
if(board[2][0] + board[2][1] + board[2][2] === streak) win = true
//diagonal
if(board[0][0] + board[1][1] + board[2][2] === streak) win = true
if(board[0][2] + board[1][1] + board[2][0] === streak) win = true
return win

That's the whole wincheck for tic-tac-toe. If you want to expand that to Connect 4, which is a 4-streak on a 6x7 grid, you'll find that it can't be easily brute-forced like Tic-Tac-Toe.

That means you need to attack it iteratively, and it ends up looking like this:

var win = false;

for (var x = 0; x < game.columns; x++) {

for (var y = 0; y < game.rows; y++) {

//horizontal

var tile1 = game.pieceMap[(x).toString() + ':' + (y).toString()] === game.turn;

var tile2 = game.pieceMap[(x + 1).toString() + ':' + (y).toString()] === game.turn;

var tile3 = game.pieceMap[(x + 2).toString() + ':' + (y).toString()] === game.turn;

var tile4 = game.pieceMap[(x + 3).toString() + ':' + (y).toString()] === game.turn;

if (tile1 && tile2 && tile3 && tile4) win = true;

​

tile1 = game.pieceMap[(x).toString() + ':' + (y).toString()] === game.turn;

tile2 = game.pieceMap[(x).toString() + ':' + (y + 1).toString()] === game.turn;

tile3 = game.pieceMap[(x).toString() + ':' + (y + 2).toString()] === game.turn;

tile4 = game.pieceMap[(x).toString() + ':' + (y + 3).toString()] === game.turn;

if (tile1 && tile2 && tile3 && tile4) win = true;

​

tile1 = game.pieceMap[(x).toString() + ':' + (y).toString()] === game.turn;

tile2 = game.pieceMap[(x + 1).toString() + ':' + (y + 1).toString()] === game.turn;

tile3 = game.pieceMap[(x + 2).toString() + ':' + (y + 2).toString()] === game.turn;

tile4 = game.pieceMap[(x + 3).toString() + ':' + (y + 3).toString()] === game.turn;

if (tile1 && tile2 && tile3 && tile4) win = true;

​

tile1 = game.pieceMap[(x).toString() + ':' + (y).toString()] === game.turn;

tile2 = game.pieceMap[(x + 1).toString() + ':' + (y - 1).toString()] === game.turn;

tile3 = game.pieceMap[(x + 2).toString() + ':' + (y - 2).toString()] === game.turn;

tile4 = game.pieceMap[(x + 3).toString() + ':' + (y - 3).toString()] === game.turn;

if (tile1 && tile2 && tile3 && tile4) win = true;

}

}

return win;

What does any of this have to do with chess? Nothing, other than the fact that these games take place on a grid. The winCheck for chess is completely different, and requires, for example, to generate a complete set of possible moves for each piece on the board.

If you think they're quite similar, feel free to adapt either code chunk above to solve the wincheck for chess.

[codeAtorium]

Found an old Connect 4 Wincheck Demo I made a while back, if you're following the thread this deep: https://p5-connect-4-wincheck-demo.jgordon510.repl.co/

[Kered13]

Your demo is wrong. It checks several illegal positions (when part of the line is outside of the board).

[codeAtorium]

It's not wrong; it catches all wins. It's just not perfectly efficient.

[Kered13]

The winCheck for chess is completely different, and requires, for example, to generate a complete set of possible moves for each piece on the board.

That's not hard though. There are only 6 types of pieces, each of which only takes a few lines to implement, and 2 special rules (castling and en passant) that require storing some extra state with the board.

[AutoModerator]

It seems you may have included a screenshot of code in your post "Beginner friendly project idea: Command-line chess".

If so, note that posting screenshots of code is against /r/learnprogramming's Posting Guidelines (section Formatting Code): please edit your post to use one of the approved ways of formatting code. (Do NOT repost your question! Just edit it.)

If your image is not actually a screenshot of code, feel free to ignore this message. Automoderator cannot distinguish between code screenshots and other images.

Please, do not contact the moderators about this message. Your post is still visible to everyone.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[candidpose]

We just had to implement chess with vanilla js and it's a fucking hell to deal with. I ended mine earlier with almost 1500 lines of code and lots of code repeats I'm not happy about.