2048 ver 1.1

앞의 버전의 2048 ver1.0은 말했듯이 기능이 매우 제한적이였다. 그래서 이번에는 조금 기능을 추가해 보았다.

기능을 추가해봤더니 코드가 570줄...ㄷㄷ...

이렇게 많이 나올줄 알았으면 처음부터 분리해서 코드를 짤걸 이라는 후회가 든다... 시간이 나면 다시 싹 뜯어 고쳐야겠다.

 

<ver 1.0과 달라진 점>

 

움직임을 입력받을 때 숫자가 아닌 w, a, s, d로 입력받게 하였다.

reset, save, load 기능 추가

점수 표시 및 undo 기능 추가 (단, undo는 10번만 가능하다.)

<다음 버전에서 수정해야 할 점>

undo는 10번만 가능하지만 save를 하면 전체 값이 저장되어서 용량의 낭비가 생기므로 그 이후의 값들은 삭제하는 방안을 이용해야겠다.

code가 너무 지저분하다...(아무리 생각을 해보더라도..) 코드를 나눠서 쓰던지 아니면 간결한 표현으로 바꿔야겠다.

 

 

아래는 소스코드이다.

1. import java.util.Scanner;
2. import java.util.Vector;
3. import java.io.*;
4.  
5. public class game {
6.     public static int score;
7.     public static int undo;
8.     public static int[] arr_score = new int [10];
9.    
10.     /*********** This is element function ***********/
11.     public static int getRand(int min, int max) {
12.         int i = (int) (Math.random()*(max - min + 1)) + min;
13.         return i;
14.     }
15.    
16.     public static void syncArr(int [][] arr, int [][] barr) {
17.         if(arr.length != barr.length)
18.             return;
19.         for(int i = 0; i < arr.length; i++) {
20.             if(arr[i].length != barr[i].length)
21.                 return;
22.             for(int j = 0; j < arr[i].length; j++)
23.                 barr[i][j] = arr[i][j];
24.         }
25.     }
26.     public static void syncArr(int []arr, int [] barr) {
27.         if(arr.length != barr.length)
28.             return;
29.         for(int i = 0; i < arr.length; i++) {
30.             barr[i] = arr[i];
31.         }
32.     }
33.  
34.     // if arr[i][j] and arr[k][l] are same, then merge it at arr[i][j]
35.     public static void merge(int [][] arr, int i, int j, int k, int l) {
36.         if(arr[i][j] == arr[k][l])
37.         {
38.             arr[i][j] = arr[i][j] + arr[k][l];
39.             arr[k][l] = 0;
40.             score = score + arr[i][j];
41.         }
42.         return;
43.     }
44.    
45.     // if arr[i][j] is 0, then move arr[k][l] to arr[i][j]
46.     public static void shift(int [][] arr, int i, int j, int k, int l) {
47.         if(arr[i][j] == 0)
48.         {
49.             arr[i][j] = arr[k][l];
50.             arr[k][l] = 0;
51.         }
52.     }
53.  
54.     public static void randNum(int [][] arr) {
55.         int i = 0; int j = 0; // i, j is index number of array
56.         if(check_Lose(arr)) {
57.             show_Lose();
58.             return;
59.         }
60.         while(true) {
61.             i = getRand(0, arr.length - 1);
62.             j = getRand(0, arr[i].length - 1);
63.             if(arr[i][j] == 0)
64.                 break;
65.         }
66.         arr[i][j] = getRand(0, 1) * 2 + 2;
67.     }
68.  
69.     /*********** This is moving function ***********/
70.     public static void L_Move(int [][] arr) {
71.         int k, l;
72.         for(int i = 0; i < arr.length; i++) {
73.             for(int j = 0; j < arr[i].length-1; j++) {
74.                 k = i; l = j;
75.                 while(l >=0) {
76.                     shift(arr, k, l, k, l+1);
77.                     l--;
78.                 }
79.             }
80.         }
81.         for(int i = 0; i < arr.length; i++) {
82.             for(int j =0; j < arr[i].length-1; j++)
83.             {
84.                 merge(arr, i, j, i, j+1);
85.             }
86.         }
87.         for(int i = 0; i < arr.length; i++) {
88.             for(int j = 0; j < arr[i].length-1; j++) {
89.                 k = i; l = j;
90.                 while(l >=0) {
91.                     shift(arr, k, l, k, l+1);
92.                     l--;
93.                 }
94.             }
95.         }
96.     }
97.    
98.     public static void R_Move(int [][] arr) {
99.         int k, l;
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.         for(int i = 0; i < arr.length; i++) {
110.             for(int j = arr[i].length - 1; j > 0; j--) {
111.                 merge(arr, i, j, i, j-1);
112.             }
113.         }
114.         for(int i = 0; i < arr.length; i++) {
115.             for(int j = arr[i].length - 1; j > 0; j--) {
116.                 k = i; l = j;
117.                 while(l < arr[i].length ) {
118.                     shift(arr, k, l, k, l-1);
119.                     l++;
120.                 }
121.             }
122.         }
123.     }
124.    
125.     public static void T_Move(int [][] arr) {
126.         int k, l;
127.         for(int j = 0; j < arr.length; j++) {      
128.             for(int i = 1; i < arr.length; i++) {
129.                 k = i; l = j;
130.                 while(k > 0 ) {
131.                     shift(arr, k-1, l, k, l);
132.                     k--;
133.                 }
134.                
135.             }
136.         }
137.         for(int j = 0; j < arr.length; j++) {      
138.             for(int i = 1; i < arr.length; i++) {
139.                 merge(arr, i-1, j, i, j);
140.             }
141.         }
142.         for(int j = 0; j < arr.length; j++) {      
143.             for(int i = 1; i < arr.length; i++) {
144.                 k = i; l = j;
145.                 while(k > 0 ) {
146.                     shift(arr, k-1, l, k, l);
147.                     k--;
148.                 }
149.                
150.             }
151.         }
152.     }
153.    
154.     public static void B_Move(int [][] arr) {
155.         int k, l;
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.         for(int j = 0; j < arr.length; j++) {
166.              for(int i = arr.length - 2; i >= 0; i--) {
167.                     merge(arr, i+1, j, i, j);
168.             }
169.         }
170.         for(int j = 0; j < arr.length; j++) {
171.              for(int i = arr.length - 2; i >= 0; i--) {
172.                 k = i; l = j;
173.                 while(k < arr.length -1 ) {
174.                     shift(arr, k+1, l, k, l);
175.                     k++;
176.                 }
177.             }
178.         }
179.     }
180.    
181.     public static boolean MoveArr(int [][] arr, String opt) {
182.         int [][] Barr = new int[arr.length][arr.length];
183.         syncArr(arr, Barr);
184.        
185.         if(opt.equalsIgnoreCase("w")) {
186.             T_Move(arr);
187.         } else if (opt.equalsIgnoreCase("s")) {
188.             B_Move(arr);
189.         } else if (opt.equalsIgnoreCase("d")) {
190.             R_Move(arr);
191.         } else if (opt.equalsIgnoreCase("a")) {
192.             L_Move(arr);
193.         } else if (opt.equalsIgnoreCase("r") || opt.equalsIgnoreCase("e") ||
194.                 opt.equalsIgnoreCase("u") || opt.equalsIgnoreCase("h") ||
195.                 opt.equalsIgnoreCase("v") || opt.equalsIgnoreCase("l")) {
196.             return false;
197.         } else {
198.             System.out.println("Error! Input right character.");
199.             return false;
200.         }
201.         // If it can move, then insert new number. If it cann't, don't insert new number.
202.         for(int i = 0; i < arr.length; i++) {
203.             for(int j = 0; j < arr[i].length; j++) {
204.                 if(Barr[i][j] != arr[i][j]) {
205.                     randNum(arr);
206.                     show_arr(arr);
207.                     return true;
208.                 }
209.             }
210.         }
211.         System.out.println("It doesn't move!");
212.         show_arr(arr);
213.         return false;
214.     }
215.    
216.     /*********** This is showing function ***********/
217.     public static void show_option() {
218.         System.out.println("Move (w : Top, s : Bottom, d : Right, a : Left) r : reset\n"
219.                 + "e : end game, u : undo, h : view high score, v : save, l : load");
220.     }
221.        
222.     public static void show_arr(int [][] arr) {
223.         System.out.println("#############################");
224.         for(int i = 0; i < arr.length; i++) {
225.             for(int j = 0; j < arr[i].length; j++) {
226.                 System.out.print(arr[i][j] + "\t");
227.             }
228.             System.out.println();
229.         }
230.         System.out.println("#############################");
231.     }
232.    
233.     public static void show_Win() {
234.         System.out.println("You Win!");
235.     }
236.  
237.     public static void show_Lose() {
238.         System.out.println("You Lose!");
239.     }
240.  
241.     /*********** checking the game end ***********/
242.     public static boolean check_Same(int [][] arr, int [][] barr) {
243.         if(arr.length != barr.length)
244.             return false;
245.         for(int i = 0; i < arr.length; i++) {
246.             if(arr[i].length != barr[i].length)
247.                 return false;
248.             for(int j = 0; j < arr[i].length; j++)
249.                 if(barr[i][j] != arr[i][j])
250.                     return false;
251.         }
252.         return true;
253.     }
254.     public static boolean check_Win(int [][] arr, int maxnum) {
255.         for(int i = 0; i < arr.length; i++) {
256.             for(int j = 0; j < arr[i].length; j++) {
257.                 if(maxnum <= arr[i][j]){
258.                     HighScore("score.txt", score);
259.                     show_Win();
260.                     return true;
261.                 }
262.             }
263.         }
264.         return false;
265.     }
266.    
267.     public static boolean check_Lose(int [][] arr) {
268.         int [][] barr = new int[arr.length][arr.length];
269.         syncArr(arr, barr);
270.         for(int i = 0; i < arr.length; i++) {
271.             for(int j = 0; j < arr[i].length; j++) {
272.                 if(arr[i][j] == 0)
273.                     return false;
274.             }
275.         }
276.         L_Move(barr);
277.         if (!check_Same(barr, arr))
278.             return false;
279.         syncArr(arr, barr);
280.         R_Move(barr);
281.         if(!check_Same(barr, arr))
282.             return false;
283.         syncArr(arr, barr);
284.         T_Move(barr);
285.         if(!check_Same(barr, arr))
286.             return false;      
287.         syncArr(arr, barr);
288.         B_Move(barr);
289.         if(!check_Same(barr, arr))
290.             return false;      
291.         show_Lose();
292.         HighScore("score.txt", score);
293.         return true;
294.     }
295.    
296.     /*********** This is setting game ***********/
297.     public static void setGame(int [][] arr) {
298.         System.out.println("GAME 2048");
299.         System.out.println("#############################");
300.         System.out.println("#    Programmed by humit.   #");
301.         System.out.println("# SEOUL NATIONAL UNIVERSITY #");
302.         System.out.println("#     Date : 2014.5.25      #");
303.         System.out.println("#############################\n");
304.         randNum(arr);
305.         randNum(arr);
306.         show_arr(arr);
307.         score = 0; undo = 10;
308.     }
309.  
310.     public static void restart(int [][] arr) {
311.         for(int i = 0; i < arr.length; i++) {
312.             for(int j = 0; j < arr[i].length; j++) {
313.                 arr[i][j] = 0;
314.             }
315.         }
316.         randNum(arr);
317.         randNum(arr);
318.         show_arr(arr);
319.         score = 0; undo = 10;
320.     }
321.    
322.     /*********** This is additional code. ***********/
323.     public static void Save_Arr(Vector<int [][]> vec, int [][] arr) {
324.         int [][] barr = new int [arr.length][arr.length];
325.         syncArr(arr, barr);
326.         vec.add(barr);
327.     }
328.    
329.     public static void Save_Game(String fileName, Vector<int[][]> vec, int [] score_arr) {
330.         File file = new File(fileName);
331.         int [][] arr = new int[4][4];
332.         try {
333.             FileWriter fw = new FileWriter(file);
334.             for(int i = 0; i < score_arr.length; i++)
335.                 fw.write(score_arr[i] + " ");
336.             fw.write("\n" + undo + "\n");
337.             for(int i = 0; i < vec.size(); i++) {
338.                 syncArr(vec.elementAt(i), arr);
339.                 for(int j = 0; j < arr.length; j++) {
340.                     for(int k = 0; k < arr.length; k++) {
341.                         fw.write(arr[j][k] + " ");
342.                     }
343.                 }
344.             }
345.             fw.close();
346.         } catch(IOException e) {
347.             e.printStackTrace();
348.         }
349.     }
350.    
351.     public static void Read_Txt(String fileName, int arr[]) {
352.         File file = new File(fileName);
353.         try {
354.             FileReader fr = new FileReader(file);
355.             BufferedReader br = new BufferedReader(fr);
356.             int nextSpace; String line;
357.             Vector<Integer> vec = new Vector<Integer>();
358.             if((line = br.readLine()) != null && !line.equals("")) {
359.                 line = line.trim();
360.                 nextSpace = line.indexOf(" ");
361.                 while(nextSpace > 0) {
362.                     vec.add(Integer.parseInt(line.substring(0, nextSpace)));
363.                     line = line.substring(nextSpace).trim();
364.                     nextSpace = line.indexOf(" ");
365.                 }
366.                 nextSpace = line.indexOf(" ");
367.                 vec.add(Integer.parseInt(line));
368.                 br.close();
369.                 for(int i = 0; i < arr.length && vec.size() - i > 0; i++) {
370.                     arr[i] = (int) vec.elementAt(vec.size()-i-1);
371.                 }
372.             }
373.         } catch (IOException e) {
374.             e.printStackTrace();
375.         }
376.     }
377.    
378.     public static boolean Load_Game(String fileName, Vector<int[][]> vec) {
379.         File file = new File(fileName);
380.         int [][] arr = new int[4][4];
381.         vec.clear();
382.         try {
383.             if(!file.exists()) {
384.                 System.out.println("There is no save file!");
385.                 return false;
386.             }
387.             FileReader fr = new FileReader(file);
388.             BufferedReader br = new BufferedReader(fr);
389.             String line;
390.             int x;  int i = 0, j = 0;
391.             Read_Txt(fileName, arr_score);
392.             int nextSpace;
393.             line = br.readLine();
394.             if((line = br.readLine()) != null && !line.equals("")) {
395.                 line = line.trim();
396.                 nextSpace = line.indexOf(" ");
397.                 undo = Integer.parseInt(line);
398.             }
399.             if((line = br.readLine()) != null && !line.equals("")) {
400.                 line = line.trim();
401.                 nextSpace = line.indexOf(" ");
402.                 while(nextSpace > 0) {
403.                     x = (Integer.parseInt(line.substring(0, nextSpace)));
404.                     arr[i%4][j%4] = x;
405.                     j++;
406.                     if( (j%4) == 0 ) {
407.                         i++;
408.                     }
409.                     if(i == 4 && j%4 == 0) {
410.                         int [][] barr = new int [4][4];
411.                         syncArr(arr, barr);
412.                         vec.add(barr);
413.                         i = i%4;
414.                     }  
415.                    
416.                     line = line.substring(nextSpace).trim();
417.                     nextSpace = line.indexOf(" ");         
418.                 }
419.                 nextSpace = line.indexOf(" ");
420.                 arr[3][3] = (Integer.parseInt(line));
421.                 int [][] barr = new int [4][4];
422.                 syncArr(arr, barr);
423.                 vec.add(barr);
424.             }
425.             score = arr_score[9];
426.             System.out.println("Score : " + score + ", Undo : " + undo);
427.             br.close();
428.             return true;
429.         } catch (IOException e) {
430.             e.printStackTrace();
431.             return false;
432.         }
433.     }
434.     public static void saveundoScore (int [] arr, int Score) {
435.         int [] barr = new int[arr.length];
436.         for(int i = 0; i < barr.length; i++)
437.             barr[i] = arr[i];
438.         arr[0] = Score;
439.         for(int i = 1; i < arr.length; i++) {
440.             arr[i] = barr[i-1];
441.         }
442.     }
443.     public static void BubbleSort(int [] arr) {
444.         for(int i = 0; i < arr.length - 1; i++) {
445.             for(int j = 0; j < arr.length -1 - i; j++) {
446.                 if(arr[j] < arr[j+1]) {
447.                     int temp = arr[j];
448.                     arr[j] = arr[j+1];
449.                     arr[j+1] = temp;
450.                 }
451.             }
452.         }
453.     }
454.     public static void HighScore(String fileName, int score) {
455.         File file = new File(fileName);
456.         int [] highScore = new int[5];
457.         try {
458.             if(!file.exists()) {
459.                 FileWriter fw = new FileWriter(fileName);
460.                 fw.write("0 0 0 0 0");
461.                 fw.close();
462.             }
463.             Read_Txt(fileName, highScore);
464.             BubbleSort(highScore);
465.             if(highScore[4] < score) {
466.                 highScore[4] = score;
467.             }
468.             BubbleSort(highScore);
469.             FileWriter fw = new FileWriter(fileName);
470.             for(int i = 0; i < 5; i++) {
471.                 String x = highScore[i] +"";
472.                 fw.write(x + " ");
473.             }
474.             fw.close();
475.         } catch (IOException e) {
476.             e.printStackTrace();
477.         }
478.     }
479.     public static void show_HighScore(String fileName) {
480.         File file = new File(fileName);
481.         try {          
482.             FileReader fr = new FileReader(file);
483.             BufferedReader br = new BufferedReader(fr);
484.             StreamTokenizer tokens = new StreamTokenizer(br);
485.             while(tokens.nextToken() != StreamTokenizer.TT_EOF) {
486.                 int x = (int) tokens.nval;
487.                 System.out.print(x + " ");
488.             }
489.             System.out.println();
490.             fr.close();
491.         } catch (IOException e) {
492.             e.printStackTrace();
493.         }
494.     }
495.    
496.     public static boolean Undo_Game(Vector<int [][]> vec, int [][] arr) {
497.         if(undo <= 0 || vec.size() <= 1 || check_Same(arr, vec.elementAt(0))) {
498.             System.out.println("Error to undo!");
499.             return false;
500.         }
501.         int [][] barr = new int [arr.length][arr.length];
502.         vec.removeElementAt(vec.size()-1);
503.         barr = vec.elementAt(vec.size()-1);
504.         vec.removeElementAt(vec.size()-1);
505.         syncArr(barr, arr);
506.         undo--;
507.         System.out.println("Undo lefts : " + undo);
508.         for(int i = 1;  i < arr_score.length; i++) {
509.             arr_score[i-1] = arr_score[i];
510.         }
511.         arr_score[9] = 10;
512.         score = arr_score[0];
513.         return true;
514.     }
515.  
516.     /*********** This is main part ***********/
517.     /* "score.txt" file is save the score. And "save.txt" file is save the game. */
518.     public static void main(String[] args) {
519.         int [][] arr = new int[4][4];
520.         String opt = " ";
521.         int num = 2048; // If make 'num' then the game ends.
522.         Vector<int [][]> vec = new Vector<int [][]>();
523.         Scanner scan = new Scanner(System.in);
524.         setGame(arr);
525.         while(!opt.equalsIgnoreCase("e")) {
526.             show_option();
527.             opt = scan.nextLine();
528.            
529.             if(opt.equalsIgnoreCase("r")) {
530.                 vec.clear();
531.                 HighScore("score.txt", score);
532.                 restart(arr);
533.             }
534.             if(opt.equalsIgnoreCase("u") && undo >= 0) {
535.                 Undo_Game(vec, arr);
536.                 Save_Arr(vec, arr);
537.                 show_arr(arr);
538.             }
539.             if(opt.equalsIgnoreCase("h")) {
540.                 show_HighScore("score.txt");
541.             }
542.             if(opt.equalsIgnoreCase("v"))
543.                 Save_Game("save.txt", vec, arr_score);
544.             if(opt.equalsIgnoreCase("l")) {
545.                 if(Load_Game("save.txt", vec)) {
546.                     arr = vec.elementAt(vec.size()-1);
547.                     show_arr(arr);
548.                 }
549.             }
550.             if(MoveArr(arr, opt)) {
551.                 System.out.println("Score : " + score);
552.                 if(!check_Win(arr, num) && !check_Lose(arr)) {
553.                     Save_Arr(vec, arr);
554.                     saveundoScore(arr_score, score);
555.                 } else {
556.                     System.out.println("If you want to play agian, type 'r'."
557.                             + "If you don't, type 'e'");
558.                     opt = scan.nextLine();
559.                     while(!opt.equalsIgnoreCase("r") && !opt.equalsIgnoreCase("e")) {
560.                         System.out.println("Error!");
561.                         opt = scan.nextLine();
562.                     }
563.                     if(opt.equalsIgnoreCase("r")) {
564.                         vec.clear();
565.                         restart(arr);
566.                     }
567.                 }
568.             }
569.         }      
570.         scan.close();
571.     }
572. }