2048 ver 1.0

게임 2048을 java를 이용해 직접 구현한 것이다. 아직 최적화도 하지 않았고, 또한 기능도 매우 제한적이다.

GUI 방식이 아닌 키보드로부터 숫자를 입력받아서 이동하는 것이다. 아래 소스코드를 첨부하였다.

여기서 할 수 있는 기능은 단지 움직이는 것만 할 수 있다. 즉, undo라던지 점수출력, 혹은 저장 및 불러오기 등 2048 게임에서 지원하는 것을 다 담지는 못하였다.

아래는 소스코드이다.

1. import java.util.Scanner;
2.  
3. public class game {
4.     /*********** This is element function ***********/
5.     public static int getRand(int min, int max) {
6.         int i = (int) (Math.random()*(max - min + 1)) + min;
7.         return i;
8.     }
9.    
10.     public static void syncArr(int [][] arr, int [][] barr) {
11.         if(arr.length != barr.length)
12.             return;
13.         for(int i = 0; i < arr.length; i++) {
14.             if(arr[i].length != barr[i].length)
15.                 return;
16.             for(int j = 0; j < arr[i].length; j++)
17.                 barr[i][j] = arr[i][j];
18.         }
19.     }
20.  
21.     // if arr[i][j] and arr[k][l] are same, then merge it at arr[i][j]
22.     public static void merge(int [][] arr, int i, int j, int k, int l) {
23.         if(arr[i][j] == arr[k][l])
24.         {
25.             arr[i][j] = arr[i][j] + arr[k][l];
26.             arr[k][l] = 0;
27.         }
28.         return;
29.     }
30.    
31.     // if arr[i][j] is 0, then move arr[k][l] to arr[i][j]
32.     public static void shift(int [][] arr, int i, int j, int k, int l) {
33.         if(arr[i][j] == 0)
34.         {
35.             arr[i][j] = arr[k][l];
36.             arr[k][l] = 0;
37.         }
38.     }
39.  
40.     public static void randNum(int [][] arr) {
41.         int i = 0; int j = 0; // i, j is index number of array
42.         if(check_Lose(arr)) {
43.             show_Lose();
44.             return;
45.         }
46.         while(true) {
47.             i = getRand(0, arr.length - 1);
48.             j = getRand(0, arr[i].length - 1);
49.             if(arr[i][j] == 0)
50.                 break;
51.         }
52.         arr[i][j] = getRand(0, 1) * 2 + 2;
53.     }
54.  
55.     /*********** This is moving function ***********/
56.     public static void L_Move(int [][] arr) {
57.         int k, l;
58.         for(int i = 0; i < arr.length; i++) {
59.             for(int j = 0; j < arr[i].length-1; j++) {
60.                 k = i; l = j;
61.                 while(l >=0) {
62.                     shift(arr, k, l, k, l+1);
63.                     l--;
64.                 }
65.             }
66.         }
67.         for(int i = 0; i < arr.length; i++) {
68.             for(int j =0; j < arr[i].length-1; j++)
69.             {
70.                 merge(arr, i, j, i, j+1);
71.             }
72.         }
73.         for(int i = 0; i < arr.length; i++) {
74.             for(int j = 0; j < arr[i].length-1; j++) {
75.                 k = i; l = j;
76.                 while(l >=0) {
77.                     shift(arr, k, l, k, l+1);
78.                     l--;
79.                 }
80.             }
81.         }
82.     }
83.    
84.     public static void R_Move(int [][] arr) {
85.         int k, l;
86.         for(int i = 0; i < arr.length; i++) {
87.             for(int j = arr[i].length - 1; j > 0; j--) {
88.                 k = i; l = j;
89.                 while(l < arr[i].length ) {
90.                     shift(arr, k, l, k, l-1);
91.                     l++;
92.                 }
93.             }
94.         }
95.         for(int i = 0; i < arr.length; i++) {
96.             for(int j = arr[i].length - 1; j > 0; j--) {
97.                 merge(arr, i, j, i, j-1);
98.             }
99.         }
100.         for(int i = 0; i < arr.length; i++) {
101.             for(int j = arr[i].length - 1; j > 0; j--) {
102.                 k = i; l = j;
103.                 while(l < arr[i].length ) {
104.                     shift(arr, k, l, k, l-1);
105.                     l++;
106.                 }
107.             }
108.         }
109.     }
110.    
111.     public static void T_Move(int [][] arr) {
112.         int k, l;
113.         for(int j = 0; j < arr.length; j++) {      
114.             for(int i = 1; i < arr.length; i++) {
115.                 k = i; l = j;
116.                 while(k > 0 ) {
117.                     shift(arr, k-1, l, k, l);
118.                     k--;
119.                 }
120.                
121.             }
122.         }
123.         for(int j = 0; j < arr.length; j++) {      
124.             for(int i = 1; i < arr.length; i++) {
125.                 merge(arr, i-1, j, i, j);
126.             }
127.         }
128.         for(int j = 0; j < arr.length; j++) {      
129.             for(int i = 1; i < arr.length; i++) {
130.                 k = i; l = j;
131.                 while(k > 0 ) {
132.                     shift(arr, k-1, l, k, l);
133.                     k--;
134.                 }
135.                
136.             }
137.         }
138.     }
139.    
140.     public static void B_Move(int [][] arr) {
141.         int k, l;
142.         for(int j = 0; j < arr.length; j++) {
143.              for(int i = arr.length - 2; i >= 0; i--) {
144.                 k = i; l = j;
145.                 while(k < arr.length -1 ) {
146.                     shift(arr, k+1, l, k, l);
147.                     k++;
148.                 }
149.             }
150.         }
151.         for(int j = 0; j < arr.length; j++) {
152.              for(int i = arr.length - 2; i >= 0; i--) {
153.                     merge(arr, i+1, j, i, j);
154.             }
155.         }
156.         for(int j = 0; j < arr.length; j++) {
157.              for(int i = arr.length - 2; i >= 0; i--) {
158.                 k = i; l = j;
159.                 while(k < arr.length -1 ) {
160.                     shift(arr, k+1, l, k, l);
161.                     k++;
162.                 }
163.             }
164.         }
165.     }
166.    
167.     public static void MoveArr(int [][] arr, int opt) {
168.         int [][] Barr = new int[arr.length][arr.length];
169.         syncArr(arr, Barr);
170.        
171.         if(opt == 0) {
172.             T_Move(arr);
173.         } else if (opt == 1) {
174.             B_Move(arr);
175.         } else if (opt == 2) {
176.             R_Move(arr);
177.         } else if (opt == 3) {
178.             L_Move(arr);
179.         } else {
180.             System.out.println("Input right number!");
181.             return;
182.         }
183.         for(int i = 0; i < arr.length; i++) {
184.             for(int j = 0; j < arr[i].length; j++) {
185.                 if(Barr[i][j] != arr[i][j]) {
186.                     randNum(arr);
187.                     show_arr(arr);
188.                     return;
189.                 }
190.             }
191.         }
192.         show_arr(arr);
193.     }
194.    
195.     /*********** This is showing function ***********/
196.     public static void show_option() {
197.         System.out.println("Move option \n\t0 : Top, 1 : Bottom, 2 : Right, 3 : Left");
198.     }
199.        
200.     public static void show_arr(int [][] arr) {
201.         System.out.println("#############################");
202.         for(int i = 0; i < arr.length; i++) {
203.             for(int j = 0; j < arr[i].length; j++) {
204.                 System.out.print(arr[i][j] + "\t");
205.             }
206.             System.out.println();
207.         }
208.         System.out.println("#############################");
209.     }
210.    
211.     public static void show_Win() {
212.         System.out.println("You Win!");
213.     }
214.  
215.     public static void show_Lose() {
216.         System.out.println("You Lose!");
217.     }
218.  
219.     /*********** checking the game end ***********/
220.     public static boolean check_Same(int [][] arr, int [][] barr) {
221.         if(arr.length != barr.length)
222.             return false;
223.         for(int i = 0; i < arr.length; i++) {
224.             if(arr[i].length != barr[i].length)
225.                 return false;
226.             for(int j = 0; j < arr[i].length; j++)
227.                 if(barr[i][j] != arr[i][j])
228.                     return false;
229.         }
230.         return true;
231.     }
232.     public static boolean check_Win(int [][] arr, int maxnum) {
233.         for(int i = 0; i < arr.length; i++) {
234.             for(int j = 0; j < arr[i].length; j++) {
235.                 if(maxnum <= arr[i][j]){
236.                     show_Win();
237.                     return true;
238.                 }
239.             }
240.         }
241.         return false;
242.     }
243.    
244.     public static boolean check_Lose(int [][] arr) {
245.         int [][] barr = new int[arr.length][arr.length];
246.         syncArr(arr, barr);
247.         for(int i =0; i < arr.length; i++) {
248.             for(int j = 0; j < arr[i].length; j++) {
249.                 if(arr[i][j] == 0)
250.                     return false;
251.             }
252.         }
253.         L_Move(barr);
254.         if (!check_Same(barr, arr))
255.             return false;
256.         syncArr(arr, barr);
257.         R_Move(barr);
258.         if(!check_Same(barr, arr))
259.             return false;
260.         syncArr(arr, barr);
261.         T_Move(barr);
262.         if(!check_Same(barr, arr))
263.             return false;      
264.         syncArr(arr, barr);
265.         B_Move(barr);
266.         if(!check_Same(barr, arr))
267.             return false;      
268.         show_Lose();
269.         return true;
270.     }
271.    
272.     /*********** This is setting game ***********/
273.     public static void setGame(int [][] arr) {
274.         System.out.println("Welcome to game 2048");
275.         randNum(arr);
276.         randNum(arr);
277.         show_arr(arr);
278.     }
279.    
280.     /*********** This is main part ***********/
281.     public static void main(String[] args) {
282.         int [][] arr = new int[4][4];
283.         int opt = 0;
284.         int num = 2048;
285.         Scanner scan = new Scanner(System.in);
286. //      System.out.println("input number");
287. //      num = scan.nextInt();
288.         setGame(arr);
289.         while(true) {
290.             if(check_Win(arr, num))
291.                 break;
292.             if(check_Lose(arr))
293.                 break;
294.         show_option();
295.         opt = scan.nextInt();
296.         MoveArr(arr, opt);
297.         }
298.         scan.close();
299.     }
300. }

휴.. 아직 갈 길이 멀군..