jfrech.com
jblog
table of contents

JSweeper

2017-05-20, post № 170

games, Java, programming, #2016, #classic, #clone, #mine, #Minesweeper, #pixel, #sweeping, #Windows

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,
  • ‘Escape’ to return to the main menu 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.

jsweeper-0.png
jsweeper-2.png
jsweeper-5.png
Source code: Main.java

Pinhole Photographs MMXVII

2017-05-06, post № 169

art, #light, #nature, #photography, #picture, #tulip, #World-Wide Pinhole Day, #WWPD

pinhole-photographs-mmxvii_purple-tulip.jpg
Purple Tulip
pinhole-photographs-mmxvii_crimson-tulip.jpg
Crimson Tulip
pinhole-photographs-mmxvii_bee-light-interference.jpg
Light Interference

Multibrot Set

2017-04-22, post № 168

Java, mathematics, programming, #animated gif, #animation, #Cartesian, #complex, #complex arithmetic, #fractal, #generalization, #gif, #Mandelbrot set, #multi-threading, #polar, #reals, #threading

The Mandelbrot Set is typically defined as the set of all numbers c\in\mathbb{C} for which — with z_0=0, z_{n+1}=f_c(z_n) and f_c(z)=z^2+c — the limit \lim\limits_{n\to\infty}z_n converges. Visualizations of this standard Mandelbrot Set can be seen in three of my posts (Mandelbrot Set, Mandelbrot Set Miscalculations and Mandelbrot Set II).

multibrot-set-1.png

However, one can extend the fractal’s definition beyond only having the exponent 𝟤 in the function to be f_c(z)=z^\text{exp}+c with \text{exp}\in\mathbb{R} [1]. The third post I mentioned actually has some generalization as it allows for \text{exp}\in\{2,3,4,5\}, although the approach used cannot be extended to real or even rational numbers.

multibrot-set-2.png

The method I used in the aforementioned post consists of manually expanding (a+b\cdot i)^n for each 𝑛. The polynomial (a+b\cdot i)^3, for example, would be expanded to (a^3-3\cdot a\cdot b^2)+(3\cdot a^2\cdot b-b^3)\cdot i.
This method is not only tedious, error-prone and has to be done for every exponent (of which there are many), it also only works for whole-number exponents. To visualize real Multibrots, I had to come up with an algorithm for complex number exponentiation.

multibrot-set-3.png

Luckily enough, there are two main ways to represent a complex number, Cartesian form z=a+b\cdot i and polar form z=k\cdot e^{\alpha\cdot i}. Converting from Cartesian to polar form is simply done by finding the number’s vector’s magnitude k=\sqrt{a^2+b^2} and its angle to the 𝑥-axis \alpha=\mbox{atan2}(\frac{a}{b}). (The function \mbox{atan2} is used in favor of \arctan to avoid having to divide by zero. View this Wikipedia article for more on the function and its definition.)
Once having converted the number to polar form, exponentiation becomes easy, as

z^\text{exp}=(k\cdot e^{\alpha\cdot i})^\text{exp}=k^\text{exp}\cdot e^{\alpha\cdot\text{exp} \cdot i}.

With the exponentiated z^\text{exp} in polar form, it can be converted back in Cartesian form with

z^\text{exp}=k^\text{exp}\cdot (\cos{(\alpha\cdot\text{exp})}+\sin{(\alpha\cdot\text{exp})}\cdot i\big).
multibrot-set-4.png

Using this method, converting the complex number to perform exponentiation, I wrote a Java program which visualizes the Multibrot for a given range of exponents and a number of frames.
Additionally, I added a new strategy for coloring the Multibrot Set, which consists of choosing a few anchor colors and then linearly interpolating the red, green and blue values. The resulting images have a reproducible (in contrast to randomly choosing colors) and more interesting (in contrast to only varying brightness) look.

multibrot-set-5.png

The family of Multibrot Sets can also be visualized as an animation, showing the fractal with an increasing exponent. The animated gif shown below was created using ImageMagick’s convert -delay <ms> *.png multibrot.gif command to stitch together the various .png files the Java application creates. To speed up the rendering, a separate thread is created for each frame, often resulting in 𝟣𝟢𝟢% CPU-usage. (Be aware of this should you render your own Multibrot Sets!)

multibrot-set-10.png

To use the program on your own, either copy the source code listed below or download the .java file. The sections to change parameters or the color palette are clearly highlighted using block comments (simply search for /*).
To compile and execute the Java application, run (on Linux or MacOS) the command javac multibrot.java; java -Xmx4096m multibrot in the source code’s directory (-Xmx4096m tag optional, though for many frames at high quality it may be necessary as it allows Java [2] to use more memory).
If you are a sole Windows user, I recommend installing the Windows 10 Bash Shell.

multibrot-set.gif
Source code: multibrot.java

Easter MMXVII

2017-04-16, post № 167

art, ascii, haiku, poetry, #ascii egg, #celebration, #easter egg, #egg

Winds swirl through the air,
Water sloshes at the shore;
A peaceful island.

                           vunnnnnnnxvvczYX                         
                       uuxrjjft///tfjrnuvvcXXUU                     
                    cuxxrf/\|(|||/tttrnxuuvcczYYJL                  
                 cuuvnxrjt/\\\/\//tffrxnuvvcccXXYYCLC               
               cccvuunxjrttttttjjfrrxnnnvvcczXzXUUUJL0              
             cczvvvuuuxnrxrrrjrxrxnnuuuvvcczXXXXYXUJJLQZ            
           czzzXzvccvnuunnnnnnnnuuuvuvvccczzzXYXYUYUJCLQO           
          zzzzXzccvvvvvuunnnnunuunnuuucvzczzXXYXUYJUJJCQ0Oq         
         XXXXzzzzcccvvvvuuvunnnnnuuuvvvcczzXzXYXXYYUUCCL0Qmp        
        XXXzXzzzzzcccccvuunnnnnnnnunvucvzzzXzYXXYUUUUJJCL0OZq       
       XYYYYXXzczzzcczcvuuunxxnxxxnuuuvzzXXXXYXUYUUUUUCJCQ0Owp      
      YYUYXYYXXXXzczczcvvuunxxrrrxnnuvuzzzzXXXYYUUUUUUJJCCL0Omd     
     YYUUYUYUXXXXczzzzcvvvunxrxrrrxxnuvcczzXzYYXYXUYUUJJLQQ0OZmk    
    YUUJJJYUYYXUXYXzczzczuuxrjrrrjrxxccccczzXXXYUYUYUJUCCCL00mwdw   
    UJCJJJUYXYXXXzzXXzzvvnxxrjjjrjxxuvvczXzXYYYXXUYUUUJCJLLL0Zmpb   
   CLLCJJJCUUUXUUXXzzzccvvunxxrrxrnuuvzzzXYXXYYYUUUYJUJJJJLL0OZwda  
   QLQLCJCUUUUUUYYXXXXXzvuuxxxrrnxxuuvvccXzXYUYUYYYUUUUCCCLLQ0Zmpk  
  00QQLLLCUJUUUUUYYYXzzzccvuuxxxxnnuvczzcXXXXUUUUYYJUYUUJCLL0QOwqk* 
  Z0OQQLLJCJUUUYUYYYXXXzzcvvnunnuuvvvvczzzXXXYYYYUYUYUJJCJLL0QOmqpa 
 0ZmZ00QLLCCJCJUUUUYYXXzzcccvvuuuucvczXXXYXYYUUUYYYUUUJJJJC0L0ZOqpkM
 ZOZO0QLLLCCCJJJUUYYXYXXYXzccvvccvczzzzXXXYYYYYUYYUYUUUUJJCCQQOZwdk*
 wwmZ0OQCQCCJJJJUUUYUYYYYXXzzzcccczXXXzXXXXYYXUYYYUUJUUJJCULQQ0Zmpbo
 qmZZZ00QQLCJUJUUJUUUUUYYXXXXzcYXXzXUXYXYYYXUUUYUUUUUUUJCJCCQQOZmqb#
 dqpZZ00QQLLLLCCJJCUUUYUYUYUXYXYYYYYYYYYYUYYUYUYYUUUYUUUJJLLQ0Omwqb*
qpqwZZOO0QLQCCCJCUJYUUUUUUYXXYYYUUUUYUYYUYJUYUYUYYYUUUJJJULLQ00mwqba
pddpwmZ000QQCQCCLCJJCJUUJUJUUUUUUYUYJUUUUUYUYJUJUUUJUJUUCCLLQ0OOmpba
qkppwwmOOO0LQLLCCCCJJJJJJUJJJUCJUUUUUUUUUJUJJUJUJUUJUCCCCCLQ00OZqqh*
 kdbpmmZZO00QQQLQLCCCJCCUCJJJUJCUJJUUUUUJJUUUUJJYUJUUJJJCLLL00OZwqk#
 ahbdqwmmOZ0Q00LLLJCCCJJJCJJJJJCUJJJYUUJUUUUUUUUUUUJUJCJCLLQOQZmqdh#
 oohdqwwZZOO0QQLLQLQCCCCLLCLCCJJJJCUJUJJJJUUUUYUJJJCCCCCCCQ0OOmmpk#*
 d*abdqqwmmOOZ00OQLQ0LCLQCCCJCLCCCJCCJJUUUJUJUUJUJUJCCCCLCQOOmwpdh# 
  M#hkbqwmZmZOOO0Q00L0QLCLLQLLQLJCLCCJJCJCUJJJJJJJJCJJLLCQ0ZmwqpkaM 
   oohkddqwmmmOZOOO0LQL0LLQCL0LCLLLLLCJCJLJJJUUJJJJCCCLQ00OZmwqba*  
   WM*akbqppwmwZOZOQOO000LQLQQLCCLLLCCCCJJCCCCJCJCLCCCLQ0OZmppboo   
    MWohhdpwqwwmwOZZZOOO00QLQLQQLLLLLCCCLLLCLCLCLLJLLQ0ZOmmwdbaa    
     &W#hkbpqwqwqZZZZZZO000QQQ0QLLQLCLLCQCLQLLLLCLLQQL0ZZmwpbkap    
      8&#ohkbddpqwwmmmZOZOOO0OO0Q0Q0QLLQQLQLLQQ0QQQ00ZOmmqbdha      
       88WMohobdbpqpwwmqZZmZZZOQZO000Q0OQQQ00QQQ000OZmmqppkk*       
        M%8M#*okkbppdqqppmwZmmmwOOZZOO00O0O0O0O0OmZqqwqdbkho        
          B@8&M**ohkbbdqppqwqwwwwwZZZmZmOOOOOZZmmwwppbbkka          
            @@8&MW*ookkkbdpdpdqpqqwqpwZwZwwmqwqpppdpdkk*            
              $$%%&WM#*oahkkhkddppdpbqwpppppbpdkkbbhho              
                @$@B8&WM**#aoaahbkkhkhkbbkkbhhkhkkab                
                   $@%%8&WWM#M#*o**oooaoooaaaaook                   
                       @%%W&WWW#*##o*oa#**#M*                       
                             #88&&%8%&                              

T-3PO — Tic-Tac-Toe Played Optimally

2017-04-08, post № 166

games, HTML, JavaScript, mathematics, programming, Python, #computer player, #game ai, #perfect, #perfect play, #three in a row, #three to win, #three

Tic-Tac-Toe, noughts and crosses, Xs and Os, three in a row or whatever you want to call it may be the simplest perfect information game that is enjoyable by humans. Two players set their pieces (X or O) on an 𝟥 ⨉ 𝟥 grid, alternating their turns. The first player to get three of their pieces in a line, wins. If no player succeeds to get a line, the game ends in a draw.

Tic-Tac-Toe’s simplicity may become clear, if you consider that skilled players — people who have played a few rounds — can reliably achieve a draw, thereby playing perfectly. Two perfect players playing Tic-Tac-Toe will — whoever starts — always tie, so one may call the game virtually pointless, due to there practically never being a winner.
Because of its simple rules and short maximal number of turns (nine) it is also a game that can be solved by a computer using brute-force and trees.

The first Tic-Tac-Toe-playing program I wrote is a Python shell script. It lets you, the human player, make the first move and then calculates the best possible move for itself, leading to it never loosing. On its way it has a little chat whilst pretending to think about its next move. The Python source code can be seen below or downloaded here.

The second Tic-Tac-Toe-playing program I wrote uses the exact same method of optimizing its play, though it lets you decide who should begin and is entirely written in JavaScript. You can play against it by following this link.

Both programs look at the entire space of possible games based on the current board’s status, assumes you want to win and randomly picks between the moves that either lead to a win for the computer or to a draw. I did not include random mistakes to give the human player any chance of winning against the computer. Other Tic-Tac-Toe-playing computers, such as Google’s (just google the game [1]), have this functionality.

Source code: t-3po.py

Second Anniversary

2017-03-28, post № 165

art, #2 years, #celebration, #collage, #j, #J-Blog, #jblog, #two years

J-Blog celebrates its second anniversary!
Exactly two years ago, on the twenty-eighth of March 2015, the very first post on this blog appeared, appropriately named “Hello World”. Since then, including this one, 𝟣𝟨𝟦 other posts have been posted. Here a few of the image highlights from both years, with their corresponding post.

                     -   
            ?][)0Zqpkdc  
         QmphM&88888%av  
        Z&88%%%8M*%B8X   
       JW&Mbw\1] ZB@b    
       ?-        #BB%c   
                 m@@@kc  
                 ?o@BBC  
                  ]&@@*v 
                   L%@%Y 
                    o@BZ 
                    LB@a 
                    ]%BM?
                     *B&v
                     k%&v
                     mBWv
                     wBWv
                     ZB* 
                     w@O 
                     W8z 
                    [BO  
                    ao]  
Ckc                k&z   
b@#Z?            [a8L    
X%$@*Q[?      ?[q%&}     
 {&%%8&kwm00mdM%%w?      
  ?ZW8%%%%%%B8&q]        
    -}\wpkpft[           

Bifurcation Diagram

2017-03-25, post № 164

mathematics, PIL, programming, Python, #alpha, #chaos, #chaos theory, #delta, #Feigenbaum, #fractal, #iterations, #Mandelbrot set, #modelling, #population

Generating the famous fractal, which can be used to model populations with various cycles, generate pseudo-random numbers and determine one of nature’s fundamental constants, the Feigenbaum constant 𝛿.
The fractal nature comes from iteratively applying a simple function, x\mapsto\lambda\cdot x\cdot (1-x) with 0\leq\lambda\leq 4, and looking at its poles.
The resulting image looks mundane at first, when looking at 0\leq\lambda\leq 3, though the last quarter section is where the interesting things are happening (hence the image below only shows the diagram for 2\leq\lambda\leq 4).
From 𝜆 = 𝟥 on, the diagram bifurcates, always doubling its number of poles, until it enters the beautiful realm of chaos and fractals.

bifurcation-diagram-1.png

For more on bifurcation, fractals and 𝛿, I refer to this Wikipedia entry and WolframMathworld.

Source code: bifurcation-diagram.py

Pi Day MMXVII

2017-03-14, post № 163

mathematics, programming, Python, #approximation, #dimensions, #four, #four dimensions, #generator, #higher dimensions, #hyperspheres

Every year on March the 14th, for one day the world gets irrationally excited about the famous constant 𝜋. As is tradition, you try to calculate 𝜋 in unusual ways, demonstrating the constant’s ubiquity as it crops up in the most unexpected circumstances.

           lnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn
       nJ$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$w
    `v$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ 
   n$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$z 
  u$$mnn:       Y$$$i        .@$$$$$,             
 $$n           )$$$*         W$$$$$m              
-n[            $$$$.        ]$$$$$$               
              h$$$w         $$$$$$Y               
             [$$$$         X$$$$$$                
            "$$$$n        '$$$$$${                
           .$$$$$         8$$$$$$                 
           *$$$$}        :$$$$$$+                 
          #$$$$u         $$$$$$%                  
        t$$$$$$         ;$$$$$$`                  
       u$$$$$$!         $$$$$$W                   
      Y$$$$$$M         .$$$$$$,                   
    f$$$$$$$$.         Z$$$$$Z          nn        
  `w$$$$$$$$|          $$$$$$(         v$z        
 n$$$$$$$$$W           $$$$$$$1      'X$8         
Y$$$$$$$$$$            *$$$$$$$8nnnn$$$p          
$$$$$$$$$@.             W$$$$$$$$$$$$$n           
_$$$$$$${                x$$$$$$$$$0>             
   -n{.                     !|nt_.                

A fairly well-known way to approximate 𝜋 is to randomly choose points in a square (often thought of as throwing darts at a square piece of cardboard), determine their distance to a circle’s center and do a division, as I did in my 𝜋 Generator post.

However, 𝜋 does not only appear in the formula for a circle’s area, A=\pi\,r^2, yet [1] also in the formula for a sphere’s volume, V=\frac{4}{3}\,\pi\,r^3, and for all the infinite hyperspheres above dimension three (view this Wikipedia article for more about volumes of higher-dimensional spheres).

In particular, the formula for the hypervolume of a hypersphere in four dimensions is defined as being V=\frac{\pi^2}{2} \cdot r^4. Using this formula, my Python script randomly chooses four-dimensional points (each in the interval \left[0,1\right)), calculates their distance to the point \left(0.5,0.5,0.5,0.5\right) and determines if they are in the hypersphere around that point with radius 𝟢.𝟧.
By dividing the number of random points which lie in the hypersphere by the number of iterations used (10^6 in the example below), the script approximates the hypersphere’s hypervolume. By then rearranging the equation V=\frac{\pi^2}{2}\cdot r^4 with 𝑟 = 𝟢.𝟧 to \pi=\sqrt{V\cdot 32}, the desired constant can be approximated.

$ python pi.py
3.14196371717
Source code: pi-day-mmxvii.py

A278328

2017-03-11, post № 162

mathematics, programming, Python, #2016, #decimal reverse, #difference, #integer, #OEIS, #On-Line Encyclopedia of Integer Sequences, #palindrome, #reverse, #sequence, #square

The On-Line Encyclopedia of Integer Sequences (also known by its acronym, OEIS) is a database hosting hundreds of thousands of — as the name implies — integer sequences. Yet, despite the massive number of entries, I contributed a new integer sequence, A278328.

A278328 describes numbers whose absolute difference to their decimal reverse are square. An example would be 𝟣𝟤 or 𝟤𝟣 (both are the decimal reverse to each other), since \left|12-21\right|=9 and 9=3^2.

Not a whole lot is known about the sequence [1], partly due to its definition only resulting in the sequence when using the decimal system, though it is known that there are infinitely many numbers with said property. Since there are infinitely many palindromes (numbers whose reverse is the number itself), \left|n-n\right|=0 and 0=0^2.

Due to there — to my knowledge — not being a direct formula for those numbers, I wrote a Python script to generate them. On the sequence’s page, I posted a program which endlessly spews them out, though I later wrote a Python two-liner, which only calculates those members of the sequence in the range from 𝟢 to 𝟫𝟪 (shown below entered in a Python shell).

>>> import math
>>> filter(lambda n:math.sqrt(abs(n-int(str(n)[::-1])))%1 == 0, range(99))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 15, 21, 22, 23, 26, 32, 33, 34, 37, 40, 43, 44, 45, 48, 51, 54, 55, 56, 59, 62, 65, 66, 67, 73, 76, 77, 78, 84, 87, 88, 89, 90, 95, 98]

Maze Solving

2017-02-27, post № 161

programming, Python PIL, #amazing, #labyrinth, #Minotaur, #solver

Mazes have been a subject of human interest for thousands of years. The Greeks used them to trap a bull-man hybrid, the French built them to show how they could impose order on nature, and even nowadays people enjoy wandering around corn mazes.
The algorithmic art of using computers to solve mazes — and even to find the shortest path through a maze —, however, has only emerged in the last couple of decades.

I was inspired by a recent Computerphile video in which Michael Pound talks about implementing different path finding algorithms for use in maze solving. And as he used Python — one of my favourite languages out there [1] —, I thought I could give it a try and came up with this maze solver.

maze-solving_normal_solved_enlarged.png

The mazes given to the solver (through a .png file) have to have a specific form. The maze needs to have a border all around (painted black) with two holes at the top and bottom, marking the maze’s start and exit (all path pixels are white).
Then the solver — using PIL — reads in the maze file, determines start and exit and starts at the maze’s start, labelling each maze path according to its shortest distance to the start. After it has found the exit, it stops looking at the maze and traces its origins back from the exit, marking the path it goes along as the maze’s optimal solution (highlighted in red).
The different hues of blue indicate the tile’s distance to the start, the white tiles are tiles the solver did not even look at.The different shadings also reveal information about the maze. Mazes with only one solution tend to have sharp changes as there are parts of the maze separated by only one wall, yet separated by a huge walk distance through the maze. The one maze with multiple solutions (see upper right image below) — in contrast — has only gradual changes in hue.

To solve a 𝟦 megapixel maze, the solver takes around 𝟥 seconds, for a 𝟣𝟨 megapixel maze around 𝟣𝟦 seconds and for a 𝟤𝟤𝟧 megapixel maze around 𝟩 minutes and 𝟤𝟤 seconds.
Performance was measured on an Intel Core i7 (𝟦.𝟢𝟢 GHz).

All mazes shown were downloaded from Michael Pound’s mazesolving GitHub repository, which were mostly generated using Daedalus.

The solver’s source code is listed below, though you can also download the .py file.

maze-solving-1_perfect2k_solved.png
maze-solving-2_braid2k_solved.png
maze-solving-3_perfect4k_solved.png
maze-solving-4_perfect10k_solved.png
maze-solving-5_perfect15k_solved.png
Source code: maze-solving.py

4096

2017-02-25, post № 160

games, Java, programming, #2016, #clone, #exponents, #jar, #powers of two

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, further connecting to the aforementioned game.

In the game, you are faced with a 𝟦 ⨉ 𝟦 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 (𝟫𝟢%) or a four-tile (𝟣𝟢%).
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.
4096-1.png
4096-3.png
4096-4.png
Source code: Main.java