Problem: Blockdude

This course’s philosophy on academic honesty is best stated as "be reasonable." The course recognizes that interactions with classmates and others can facilitate mastery of the course’s material. However, there remains a line between enlisting the help of another and submitting the work of another. This policy characterizes both sides of that line.

The essence of all work that you submit to this course must be your own. Collaboration on problems is not permitted (unless explicitly stated otherwise) except to the extent that you may ask classmates and others for help so long as that help does not reduce to another doing your work for you. Generally speaking, when asking for help, you may show your code or writing to others, but you may not view theirs, so long as you and they respect this policy’s other constraints. Collaboration on quizzes and tests is not permitted at all. Collaboration on the final project is permitted to the extent prescribed by its specification.

Below are the rules of thumb that (inexhaustibly) characterize acts that the course considers reasonable and not reasonable. If in doubt as to whether some act is reasonable, do not commit it until you solicit and receive approval in writing from your instructor. If a violation of this policy is suspected and confirmed, your instructor reserves the right to impose local sanctions on top of any disciplinary outcome that may include an unsatisfactory or failing grade for work submitted or for the course itself.

Your work on this problem set will be evaluated along four axes primarily.

To obtain a passing grade in this course, all students must ordinarily submit all assigned problems unless granted an exception in writing by the instructor.

First, log into cs50.io and execute

within a terminal window to make sure your workspace is up-to-date.

Then, create a new directory inside of your workspace called unit6 (Remember how?) and navigate inside. Once there, obtain a copy of this problem’s distro by typing:

Unzip the ZIP file and then delete the ZIP file from your unit6 directory (remember how?). Navigate into your newly-created block dude folder and execute

after which you should see that your directory contains eight files.

Confirm that all the files are, indeed, in your directory and let’s get started, shall we?

For this problem, we’ll implement a game called blockdude. For some, this game may ring a bell and for others, it may not. Blockdude is a game played on the TI83/84 calculators back in the day. Take a look at this video below to see the game in action and understand how it works.

Before we continue on, remember adjusting your terminal window to be the right size to play sudoku? Here too must we adjust the terminal window to be a accommodating for the game. If you type

your prompt should change, telling you that every two seconds it is updating what it perceives as the number of lines in your terminal window. If you drag your window up and down, you should see the number a few lines down update. When it says "46", you can press ctrl+C to quit the put program. Similarly, you can type

to figure out how many columns your terminal window has. When you stretch or shrink your window and it reports "68", you can press ctrl+C to quit.

If you don’t remember why we need this specific terminal size, it’s because ncurses individually addresses each character in your terminal window by way of (y,x) coordinates, whereby (0,0) refers to your terminal window’s top-left corner and (45,67) refers to the bottom-right corner.

Open up blockdude.c and you’ll see that an old friend has revisited us: ncurses! In case you’ve forgotten, ncurses was used back in Unit 4 to help implement sudoku. ncurses provides us with an API that allows us to create a rudimentary GUI in a terminal-independent manner.

Now about that skeleton. Odds are you’ll read through the code and not understand most of the code. Basically, we’ve implemented the aesthetics for the game as well as the left and right movements so that you can focus on other parts of the game. But know that none of it is all that complex. In fact, if you look at each of the functions in isolation, you’ll likely find each pretty straightforward.

Navigate to your ~/workspace/chapterB/blockdude directory and execute the increasingly familiar command below:

You should find a brand new executable called blockdude in your current working directory. Go ahead and run it by typing

and you should see the game appear in your terminal window, something like the picture below. If not, do just check again to ensure your terminal dimensions are correct.

If you read through main, you’d have seen that the program allows for one additional command line argument, a level code, or an int, that specifies which level you’d like to start. If no command line argument is given or an incorrect level code, the game will start at level 1.

Now back to the game. The many =s represent bricks on which you walk, the #s represent blocks that you may pick up, if possible, and move, and the * represents the level’s exit that you must reach.

If you press the left or right arrow keys, you’ll find that the character will move. Try moving around to get a sense of how the character moves.

But trying to pick up the # block with the up arrow key, you’ll see that the character can’t pick it up. Looking back through the distro, you’ll see in the reposition function that case KEY_UP: and case KEY_DOWN: have yet to be implemented!

To test the staff’s solution, and ultimately how your solution should work, execute the below:

Now open up blockdude.h. Here, you’ll see a lot of #defines that we use in blockdude.c. Of interest to you will be DISPLACE, SPACE, BRICK, BLOCK, PRIGHT, and PLEFT.

For our implementation of blockdude, all bricks have been separated by 2 units, or displaced (hence the #define DISPLACE 2), for aesthetic purposes. Thus, when we mean something is to the right of something, we actually mean 2 units to the right.

Next, is SPACE, BRICK, and BLOCK, which are exactly what they sound like. SPACE just denotes empty space. BRICK represents the bricks for the level layout. And BLOCK is the blocks the character may pick up and drop in order to pass the level.

Finally, though the character initially starts off as the letter O (denoted by the #define PLAYER 'O'), when the character moves, the O becomes a < if moving to the left and a > if moving the right. Thus, PRIGHT and PLEFT represent which way the character is facing, and thus which way it should pick up and drop blocks.

Here’s what lies ahead.

Complete the implementation of reposition such that when the user presses the up or down arrow keys, the character picks up or puts down a block if possible.

While completing the KEY_UP case for reposition, keep in mind the following.

And for the KEY_DOWN case, the following.

For both KEY_UP and KEY_DOWN, odds are code will take into consideration when the character is facing left and when it’s facing right.

Odds are you’ll find the functions inch, mvinch, and mvaddch of the ncurses library of use.

If in need of some inspiration, take a look at the case KEY_LEFT: and case KEY_RIGHT: parts of reposition as well as the check_win function.

And if confused on how your implementation should work after completion of reposition, test the staff’s implementation!

Upon completing reposition, try playing around with your implementation of blockdude and test if all runs smoothly and as expected.

And if you’d like, try beating all 5 levels of the game!

This was Blockdude.