Advertisement
Guest User

Untitled

a guest
Oct 27th, 2016
66
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 9.17 KB | None | 0 0
  1. package game;
  2.  
  3. import javax.swing.*;
  4. import java.awt.*;
  5. import java.awt.event.*;
  6.  
  7.  
  8. /**
  9.  * Created by d.nurgaleev on 24.10.2016.
  10.  */
  11. public class Field extends JPanel {
  12.     public static final int width = 8;
  13.     public static final int height = 8;
  14.     public static final int scale = 40;
  15.     private Game gamer;
  16.     public static JFrame frame = new JFrame();
  17.  
  18.     public Field() {
  19.         frame = frame1("2048");
  20.         gamer = new Game();
  21.         gamer.start();
  22.         frame.addKeyListener(new KeyAdapter() {
  23.             @Override
  24.             public void keyPressed(KeyEvent e) {
  25.                 gamer.keyPressed(e);
  26.                 repaint();
  27.             }
  28.         });
  29.     }
  30.  
  31.     public void paint(Graphics g) {
  32.  
  33.         g.setColor(color(230, 230, 230));
  34.         g.fillRect(0, 0, width * scale, height * scale);
  35.         g.setColor(color(100, 100, 100));
  36.         for (int i = 0; i < width * scale; i = i + scale * 2) {
  37.             g.drawLine(i, 0, i, height * scale);
  38.             g.drawLine(0, i, width * scale, i);
  39.         }
  40.         g.setColor(color(0,0,0));
  41.         Font myFont = new Font("Times New Roman", Font.BOLD, 20);
  42.         g.setFont(myFont);
  43.         int y = 0;
  44.         for (int i = 0; i < 4; i++) {
  45.             int x = 0;
  46.             for (int j = 0; j < 4; j++) {
  47.                 if (Game.num[i][j] == 4)
  48.                 {
  49.                     g.setColor(color(0,255,0));
  50.                     g.fillRect(0,j*scale*2,scale*2,scale*2);
  51.                 }
  52.                 g.setColor(color(0,0,0));
  53.                 g.drawString("" + Game.num[i][j], scale - 5 + x, scale + 5 + y);
  54.                 x = x + scale * 2;
  55.             }
  56.             y = y + scale * 2;
  57.         }
  58.     }
  59.  
  60.     public Color color(int red, int green, int blue) {
  61.         return new Color(red, green, blue);
  62.     }
  63.  
  64.  
  65.     public JFrame frame1(String s) {
  66.         JFrame frame1 = new JFrame();
  67.         frame1.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
  68.         frame1.setResizable(false);
  69.         frame1.setSize(width * scale + 5, height * scale + 30);
  70.         frame1.setLocationRelativeTo(null);
  71.         frame1.add(this);
  72.         frame1.setVisible(true);
  73.         return frame1;
  74.     }
  75.  
  76.     public static void main(String[] args) {
  77.         Field field = new Field();
  78.  
  79.  
  80.     }
  81.  }
  82.  
  83.  
  84.  
  85.  
  86.  
  87.  
  88. package game;
  89.  
  90. import javax.swing.*;
  91. import java.awt.event.KeyAdapter;
  92. import java.awt.event.KeyEvent;
  93. import java.util.Random;
  94.  
  95. /**
  96.  * Created by d.nurgaleev on 24.10.2016.
  97.  */
  98. public class Game {
  99.     public int random(int a, int b) {
  100.         return a + (int) (Math.random() * b);
  101.     }
  102.     public static int[][] num = new int[4][4];
  103.     public int def = 2;
  104.  
  105.     public void keyPressed(KeyEvent e) {
  106.         if (e.getKeyCode() == KeyEvent.VK_DOWN) {
  107.             down();
  108.         }
  109.         if (e.getKeyCode() == KeyEvent.VK_RIGHT) {
  110.             right();
  111.         }
  112.         if (e.getKeyCode() == KeyEvent.VK_UP) {
  113.             up();
  114.         }
  115.         if (e.getKeyCode() == KeyEvent.VK_LEFT) {
  116.             left();
  117.         }
  118.     }
  119.  
  120.     public void start() {
  121.         num[random(0,4)][random(0,4)] = def;
  122.         num[random(0,4)][random(0,4)] = def;
  123.         for(int i = 0; i < 4; i++)
  124.         {
  125.             for (int j = 0; j < 4; j++)
  126.             {
  127.                 System.out.print(num[i][j] + " ");
  128.             }
  129.             System.out.println();
  130.         }
  131.     }
  132.  
  133.     public void down() {
  134.         int zn = 0;
  135.         System.out.println();
  136.         for(int j = 0; j < 4; j++) {
  137.             for (int i = 3; i >= 0; i--) {
  138.                 if(num[i][j] == 0) {
  139.                     int k = i - 1;
  140.                     while(k > 0)
  141.                     {
  142.                         if(num[k][j] != 0) break;
  143.                         k--;
  144.                     }
  145.                     if(k >=0) {
  146.                         num[i][j] = num[k][j];
  147.                         num[k][j] = 0;
  148.                     }
  149.                 }
  150.  
  151.                 if(num[i][j] != 0)
  152.             {
  153.                     int k = i - 1;
  154.                     while(k > 0)
  155.                     {
  156.                         if(num[k][j] != 0) break;
  157.                         k--;
  158.                     }
  159.                 if (k>=0 && num[i][j] == num[k][j]) {
  160.                     num[i][j] = num[i][j] * 2;
  161.                     num[k][j] = 0;
  162.                 }
  163.  
  164.             }
  165.  
  166.             }
  167.         }
  168.  
  169.         System.out.println();
  170.         int a = random(0,4);
  171.         int b = random(0,4);
  172.         while (num[a][b] != 0)
  173.         {
  174.             a = random(0,4);
  175.             b = random(0,4);
  176.         }
  177.         num[a][b] = def;
  178.         for(int i = 0; i < 4; i++)
  179.         {
  180.             for (int j = 0; j < 4; j++)
  181.             {
  182.                 System.out.print(num[i][j] + " ");
  183.             }
  184.             System.out.println();
  185.         }
  186.     }
  187.  
  188.     public void right() {
  189.         int zn = 0;
  190.         System.out.println();
  191.         for(int i = 0; i < 4; i++) {
  192.             for (int j = 3; j >= 0; j--) {
  193.                 if(num[i][j] == 0) {
  194.                     int k = j - 1;
  195.                     while(k > 0)
  196.                     {
  197.                         if(num[i][k] != 0) break;
  198.                         k--;
  199.                     }
  200.                     if(k >=0) {
  201.                         num[i][j] = num[i][k];
  202.                         num[i][k] = 0;
  203.                     }
  204.                 }
  205.  
  206.                 if(num[i][j] != 0)
  207.                 {
  208.                     int k = j - 1;
  209.                     while(k > 0)
  210.                     {
  211.                         if(num[i][k] != 0) break;
  212.                         k--;
  213.                     }
  214.                     if (k>=0 && num[i][j] == num[i][k]) {
  215.                         num[i][j] = num[i][j] * 2;
  216.                         num[i][k] = 0;
  217.                     }
  218.  
  219.                 }
  220.  
  221.             }
  222.         }
  223.  
  224.  
  225.         int a = random(0,4);
  226.         int b = random(0,4);
  227.         while (num[a][b] != 0)
  228.         {
  229.             a = random(0,4);
  230.             b = random(0,4);
  231.         }
  232.         num[a][b] = def;
  233.         for(int i = 0; i < 4; i++)
  234.         {
  235.             for (int j = 0; j < 4; j++)
  236.             {
  237.                 System.out.print(num[i][j] + " ");
  238.             }
  239.             System.out.println();
  240.         }
  241.     }
  242.  
  243.     public void up() {
  244.         int zn = 0;
  245.         System.out.println();
  246.         for(int j = 0; j < 4; j++) {
  247.             for (int i = 0; i < 4; i++) {
  248.                 if(num[i][j] == 0) {
  249.                     int k = i + 1;
  250.                     while(k < 4)
  251.                     {
  252.                         if(num[k][j] != 0) break;
  253.                         k++;
  254.                     }
  255.                     if(k < 4) {
  256.                         num[i][j] = num[k][j];
  257.                         num[k][j] = 0;
  258.                     }
  259.                 }
  260.  
  261.                 if(num[i][j] != 0)
  262.                 {
  263.                     int k = i + 1;
  264.                     while(k < 4)
  265.                     {
  266.                         if(num[k][j] != 0) break;
  267.                         k++;
  268.                     }
  269.                     if (k < 4 && num[i][j] == num[k][j]) {
  270.                         num[i][j] = num[i][j] * 2;
  271.                         num[k][j] = 0;
  272.                     }
  273.  
  274.                 }
  275.  
  276.             }
  277.         }
  278.  
  279.         System.out.println();
  280.         int a = random(0,4);
  281.         int b = random(0,4);
  282.         while (num[a][b] != 0)
  283.         {
  284.             a = random(0,4);
  285.             b = random(0,4);
  286.         }
  287.         num[a][b] = def;
  288.         for(int i = 0; i < 4; i++)
  289.         {
  290.             for (int j = 0; j < 4; j++)
  291.             {
  292.                 System.out.print(num[i][j] + " ");
  293.             }
  294.             System.out.println();
  295.         }
  296.     }
  297.  
  298.  
  299.     public void left() {
  300.         int zn = 0;
  301.         System.out.println();
  302.         for(int i = 0; i < 4; i++) {
  303.             for (int j = 0; j < 4; j++) {
  304.                 if(num[i][j] == 0) {
  305.                     int k = j + 1;
  306.                     while(k < 4)
  307.                     {
  308.                         if(num[i][k] != 0) break;
  309.                         k++;
  310.                     }
  311.                     if(k < 4) {
  312.                         num[i][j] = num[i][k];
  313.                         num[i][k] = 0;
  314.                     }
  315.                 }
  316.  
  317.                 if(num[i][j] != 0)
  318.                 {
  319.                     int k = j + 1;
  320.                     while(k < 4)
  321.                     {
  322.                         if(num[i][k] != 0) break;
  323.                         k++;
  324.                     }
  325.                     if (k < 4 && num[i][j] == num[i][k]) {
  326.                         num[i][j] = num[i][j] * 2;
  327.                         num[i][k] = 0;
  328.                     }
  329.  
  330.                 }
  331.  
  332.             }
  333.         }
  334.  
  335.  
  336.         int a = random(0,4);
  337.         int b = random(0,4);
  338.         while (num[a][b] != 0)
  339.         {
  340.             a = random(0,4);
  341.             b = random(0,4);
  342.         }
  343.         num[a][b] = def;
  344.         for(int i = 0; i < 4; i++)
  345.         {
  346.             for (int j = 0; j < 4; j++)
  347.             {
  348.                 System.out.print(num[i][j] + " ");
  349.             }
  350.             System.out.println();
  351.         }
  352.     }
  353. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement