## JSweeper

Adding to my collection of clones of popular, well-known games, I created back in November of 2016 a Java-implementation of the all-time Windows classic game, Minesweeper.

Minesweeper was pre-installed on every installation of Windows up to and including Windows 7 and has been ported to a variety of different systems. Because of this, nearly everyone has at least once in their life played Minesweeper or at least heard of it.
In Minesweeper you are presented with a square grid of covered tiles containing either numbers or mines. Your task is it to uncover all tiles which are not mines in the least amount of time. When you uncover a mine, it explodes and the game is lost. To aid in figuring out which tiles are mines and which are not, every tile that is not a mine tells you how many mines are in the neighbouring eight tiles. Tiles which have no neighbouring mines are drawn gray and uncover neighbouring non-mine tiles once uncovered.
More on Minesweeper can be found in this Wikipedia article — I am linking to the German version, as the current English version has major flaws and lacks crucial information. If you are so inclined, feel free to fix the English Minesweeper Wikipedia article.

In my clone, there are three pre-defined difficulty levels, directly ported from the original Minesweeper game, and an option to freely adjust the board’s width and height as well as the number of bombs which will be placed. Gameplay is nearly identical to the original, as my clone also uses a square grid and the tile’s numbers correspond to the number of bombs in the eight tiles surrounding that tile.
The game has a purposefully chosen pixel-look using a self-made font to go along with the pixel-style.

#### Controls

• Arrow keys and enter to navigate the main menu
• Arrow keys or mouse movement to select tiles
• Space, enter or left-click to expose a tile
• ‘f’ or right-click to flag a tile
• ‘r’ to restart game when game is either won or lost
• F11 toggles fullscreen

To play the game, you can either download the .jar file or compile the source code for yourself. The source code is listed below and can be downloaded as a .java file.

``````// Java 1.6 / 1.8 code
// Jonathan Frech  5th of November, 2016
//         edited  7th of November, 2016
//         edited 11th of November, 2016
//         edited 13th of November, 2016
//         edited 14th of November, 2016
//         edited 15th of November, 2016
//         edited 17th of November, 2016
//         edited 19th of November, 2016
//         edited 19th of May     , 2017
//         edited 22nd of May     , 2017
//          * fixed max mine cap when
//            using custom settings``````

## 4096

4096 is a Java-based clone of the well-known web and mobile game 2048, which itself clones 1024 and is similiar to THREES. The naming trend is quite obvious, though note that $2^{12}$ is a power of two where the exponent is divisible by three, futher connecting to the aforementioned game.

In the game, you are faced with a 4×4 matrix, containing powers of two. By swiping in the four cardinal directions (e.g. pressing the arrow keys), you shove all the non-empty cells to that side. When two equal powers of two collide, they fuse together, adding. Once you shoved, an empty tile pseudo-randomly transforms to either a two-tile (90%) or a four-tile (10%).
Your objective at first is to reach the tile 4096, though the real goal is to achieve the highest score. Your score is the sum of all the collisions you managed to cause.

To play 4096, you can either download the .jar file or review and compile the game for yourself, using the source code listed below.

#### Controls

• Up, down, left or right arrow key shoves the tiles
• Escape restarts the game upon a loss
• F11 toggles fullscreen

``````// Java 1.8 Code
// Jonathan Frech,  5th of December 2016
//          edited  6th of December 2016
//          edited  7th of December 2016
//          edited  8th of December 2016
//          edited  9th of December 2016
//          edited 19th of February 2017
//          edited 24th of February 2017
//          edited 28th of February 2017
//          * gave the 4096 tile a color
//          edited 22nd of April    2017
//          * fixed window positioning by changing
//            frame.setLocationRelativeTo(null); to
//            frame.setLocationByPlatform(true);``````

## RGB Jallenge

This is a clone of The Great RGB Guessing Challenge.
The challenge works like this: You are presented three numbers ranging from 0 to 255 representing a rgb color and three color bubbles. To get a point you must choose the color bubble corresponding to the rgb values. The more points you get, the higher your score.

#### Controls

• Click on the bubble to choose it

``````# Python 2.7.7 Code
# Pygame 1.9.1 (for Python 2.7.7)
# Jonathan Frech 8th of July, 2016``````

## Jimon

This game is a recreation of the famous game Simon. In the game there are four colors which form a sequence that is expanding every cycle. The aim of the game is to memorize said sequence as far as possible.

#### Controls

• Click on the colored buttons to press them

``````# Python 2.7.7 Code
# Pygame 1.9.1 (for Python 2.7.7)
# Jonathan Frech 24th of June, 2016``````

## Sliding Puzzle

This is my version of a sliding puzzle.
A sliding puzzle is based on a number of tiles (15 in this case) which are scrambled.
The objective of the game then is to slide the tiles around and get back to the original image.
As an image I took a photo of an apple in front of a black background.

#### Controls

• F1 takes a screenshot
• F2 starts and stops scrambling the image
• F3 solves the puzzle
• Mouse clicks slide tiles

``````# Python 2.7.7 Code
# Pygame 1.9.1 (for Python 2.7.7)
# Jonathan Frech 15th of April, 2016
#         edited 16th of April, 2016``````

## Jappy Jird

This game is a clone of the famous international hit Flappy Bird.
You control the little pixel-bird, while it flaps through three different scenes and tries to avoid deadly pipes. Your score is measured by how many pipes you can pass.

#### Controls

• Escape pauses and resumes the game
• F1 takes a screenshot
• Up arrow keys makes the bird flap

``````# Python 2.7.7 Code
# Pygame 1.9.1 (for Python 2.7.7)
# Jonathan Frech 29th of March, 2016
#         edited 30th of March, 2016
#         edited 31st of March, 2016``````

## Conway’s Game of Life

This program is a simulation of the famous cellular automaton created by John Conway. The so-called ‘game’ is rather a simulated evolution of cells in a two-dimensional world. Each cell can either be dead (black) or alive (white) and always has eight neighbours surrounding them. In each cycle of the simulation their state will be changed based on two simple rules, which are listed below.
Despite the rule’s simplicity, the outcomes are often very interesting and complex.
For more details on the game of life, check this Wikipedia entry.

#### The rules

• A live cell can only survive with exactly 2 or 3 neighbours, or else it dies.
• A dead cell with exactly 3 neighbours comes to life.

#### Controls

• Left click turns cell at current mouse position alive
• Right click turns cell at current mouse position dead
• ‘r’ turns every cell dead
• ‘q’ cycles once
• ‘w’ cycles continuously

``````# Python 2.7.7 Code
# Pygame 1.9.1 (for Python 2.7.7)
# Jonathan Frech 12th of February, 2016``````

## Jonnect Jour

After having programmed Jic-Jac-Joe – where you need to connect three pieces –, I now programmed Connect Four (four pieces).
This version – although it does not have a computer player – includes win detection.

#### Controls

• Left clicking puts your piece where the mouse cursor is positioned
• Escape restarts the game

``````# Python 2.7.7 Code
# Pygame 1.9.1 (for Python 2.7.7)
# Jonathan Frech 13th of August, 2015
#         edited 14th of August, 2015``````

## Jeakout

Continuing with my arcade game replicas, I programmed Breakout.
This version is fairly simple. Your lives will be displayed at the lower right corner, your points in the screen’s caption. There also is a computer implementation, which – as in Jong – cannot lose.

#### Usage

• Left arrow key moves the hitter to the left
• Right arrow key moves the hitter to the right
• Space toggles computer play

``````# Python 2.7.7 Code
# Pygame 1.9.1 (for Python 2.7.7)
# Jonathan Frech 14th of June, 2015
#         edited 27th of July, 2015``````

## Jic-Jac-Joe

As the name suggests, this is a computer version of the well-known game Tic-Tac-Toe. This version supports a computer player, but it is not the smartest algorithm and can lose. In this setup, the computer plays ‘O’ and starts, the player plays ‘X’.
Win detection is fully implemented.

#### Controls

• The 3×3-field is projected on the numpad
• So 7 sets your piece in the upper left corner
• And 3 puts it in the lower right corner
• Escape resets the game

``````# Python 2.7.7 Code
# Pygame 1.9.1 (for Python 2.7.7)
# Jonathan Frech  9th of July, 2015
#         edited 10th of July, 2015``````