Java版SLG游戏开发入门[2]--数据的读取及保存

 

  说到SLG游戏开发，无论其如何运转，里面都离不开各种数据的处理，一般来说，游戏越专业，需要处理的数据量将相对越大，类别也分得越细。

 

  游戏离不开美工，也离不开策划，各项参数的专业划分同样是评价一款SLG游戏是否优秀的必要指标之一。所谓的好游戏仅仅画面出彩，配乐一流是绝对不够的，做“靓”很容易，做“专”则很难。

 

  比如日本的超级机器人大战系列，自90年代初开始出现以来，截止到今天为止其中涉及的动漫超过60部，出场知名人物多达600名以上，几乎涵盖了日本所有知名机器人动画的机体（当然也有遗憾，比如机动警察）。这些角色无分善恶是各有各的fans，各有各的崇拜者。请这些“天王”出场，如果还做不好，过强或者过弱某一方，或者该出现的“华丽”技能没有出现，日本这些“ACG宅”的愤怒可是很恐怖的，正所谓“秋叶原前一声吼，东京也要抖三抖”。

 

  对动漫人物的把握程度，对角色参数的设定，起了尤为重要的作用。

 

  在这里鄙人不由得想起某位大神，就是SRC (Simulation RPG Construction)的作者鬼子Kei。这家伙从90年代末就用VB5.0开始制作SRC这个机战的同人制作工具，而我这辈子读的第一段程序代码，也正是某杂志随盘附录的SRC0.6版及其源码，当时我连VB是什么都不知道，彻底的读天书，于是才买书钻研VB……一晃10年，VB6.0我都已放下很久，他居然还在更新SRC，而且还是使用VB5开发，我不由惊叹鬼子的勤奋还有专注。10年工夫，我是无论如何也不信Kei不会用更简便的工具来制作SRC的，但是他却没有，硬是把VB5这个现在很多人用都没用过的古董级工具（实际上我也没用过|||）做出一款亚洲知名的机战同人开发工具来，10年来此人网站流量累计超过1690万，而且我也真的见过很多同人爱好者的SLG游戏是采用SRC开发。日本人真是恐怖，居然有人能甘心钻研VB5如此之久，如果把这种劲头用在工作上，想想我都不寒而栗，有这样的恒心这样弃而不舍的精神，在亚洲中国最大的潜在对手始终非日本莫属……咳咳，扯远了。

 SRC运行画面，运行需要VB5运行库，并日文Windows环境。（或者先用AppLocale转内码，再转日文脚本乱码后载入）

 

  通常来讲，我们不太可能将各种游戏数据硬编码到程序中，这样既不利于测试，也不方便重用，总需要一个外部文件作为存储介质。这时的选择其实很多，在Java游戏开发中我们即可以使用xml这类现有的规范格式，也可以干脆如SRC般自己定义脚本，或者将少量数据利用properties存储。

 

  就我个人认为，自己订制游戏脚本格式从长远看是最可取的，以后的同类项目方便重用，也不容易被他人盗取数据。而xml虽然有很多现成的组件可用，但是处理复杂业务时就没有自己的脚本用着方便，而且当数据很少时也有些杀鸡用牛刀的感觉。至于properties，存取单键值的数据固然很方便，但是对于表格类的数据，即使很简单也不适用，至少不直观了。

 

  在本例中我所采用的，是一种更为偷懒的方式，并不归属于以上所说，而是另辟蹊径的利用csv格式，实现了一种较为另类的表格式数据存储。

 

   CSV（Comma Separated value），也叫逗号分隔值文件，是一种用来存储数据的纯文本文件格式，通常用于电子表格或数据库软件。我们打开windows记事本，随便打几个字母用“,”分割，再用excel查看，这时excel就会自动以表格方式显示这些数据。

 

 

 

  同样对于Java中的表格数据存储，也可以采用了这种方式保存，并且利用reflect机制映射到类，看上去即直观，也比xml省心，比自己写脚本省力。

  核心代码如下：

1. package org.loon.simple.slg.utils;
4. import java.io.IOException;
5. import java.lang.reflect.Array;
6. import java.util.ArrayList;
7. import java.util.HashMap;
8. import java.util.Iterator;
9. import java.util.List;
10. import java.util.Map;
11. import java.util.Set;
12. import java.util.Map.Entry;
14. /**
15.  * Copyright 2008
16.  * 
17.  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
18.  * use this file except in compliance with the License. You may obtain a copy of
19.  * the License at
20.  * 
21.  * http://www.apache.org/licenses/LICENSE-2.0
22.  * 
23.  * Unless required by applicable law or agreed to in writing, software
24.  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
25.  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
26.  * License for the specific language governing permissions and limitations under
27.  * the License.
28.  * 
29.  * @project loonframework
30.  * @author chenpeng
31.  * @email：[email protected]
32.  * @version 0.1
33.  */
34. public class CSVConfigure {
36.     /**
37.      * 载入CSV数据后转化为指定类的Object[]
38.      * 
39.      * @param fileName
40.      * @param clazz
41.      * @return
42.      */
43.     final static public Object[] loadPropertys(final String fileName,
44.             final Class clazz) {
45.         Object[] results = null;
46.         try {
47.             List properts = CSVConfigure.loadPropertys(fileName);
48.             int size = properts.size();
49.             results = (Object[]) Array.newInstance(clazz, size);
50.             for (int i = 0; i < size; i++) {
51.                 Map property = (Map) properts.get(i);
52.                 Set set = property.entrySet();
53.                 results[i] = clazz.newInstance();
54.                 for (Iterator it = set.iterator(); it.hasNext();) {
55.                     Entry entry = (Entry) it.next();
56.                     ClassUtils.beanRegister(results[i],
57.                             (String) entry.getKey(), (String) entry.getValue());
58.                 }
59.             }
60.         } catch (Exception ex) {
61.             throw new RuntimeException(ex+" "+fileName);
62.         }
63.         return results;
64.     }
66.     /**
67.      * 载入CSV数据到List
68.      * 
69.      * @param fileName
70.      * @return
71.      */
72.     final static public List loadPropertys(final String fileName) {
73.         List result = new ArrayList();
74.         try {
75.             CSVReader csv = new CSVReader(fileName);
76.             List names = csv.readLineAsList();
77.             int length = names.size();
78.             for (; csv.ready();) {
79.                 Map propertys = new HashMap(length);
80.                 String[] csvItem = csv.readLineAsArray();
81.                 for (int i = 0; i < length; i++) {
82.                     propertys.put((String) names.get(i), csvItem[i]);
83.                 }
84.                 result.add(propertys);
85.             }
86.         } catch (IOException e) {
87.             e.printStackTrace();
88.         }
89.         return result;
90.     }
92. }

  使用方法：

1. friends = (Friend[]) CSVConfigure.loadPropertys(FRIEND_FILE_NAME,
2.                 Friend.class);

   只是一个很简单的反射，就可以将CSV表格数据注射到类上。

 

   再说一下游戏数据的存储，一般来讲就是指游戏记录，这在Java中是最好办的。因为只要你的关键数据对象实现serializable，大可以直接将当前状态序列化到本地文件中，不过是ObjectInputStream和ObjectOutputStream的把戏罢了。

 

  如果没有或者你不想的话，你只要将关键数据以某种格式保存（这个真是随便，能再读出来就成），然后再反馈给游戏即可。实际上我们都知道所谓读档/保存并不是时间真的重来了，而是数据被还原罢了。

  用例代码：

1. package org.loon.simple.slg.utils;
2. 
   
3. import java.io.BufferedInputStream;
4. import java.io.BufferedOutputStream;
5. import java.io.BufferedReader;
6. import java.io.ByteArrayInputStream;
7. import java.io.ByteArrayOutputStream;
8. import java.io.File;
9. import java.io.FileInputStream;
10. import java.io.FileOutputStream;
11. import java.io.IOException;
12. import java.io.InputStream;
13. import java.io.InputStreamReader;
14. import java.io.OutputStream;
15. import java.io.Reader;
16. import java.io.UnsupportedEncodingException;
17. import java.net.URLDecoder;
18. import java.net.URLEncoder;
19. import java.util.ArrayList;
20. import java.util.List;
21. import java.util.zip.GZIPInputStream;
22. import java.util.zip.GZIPOutputStream;
23. 
    
24. /**
25.  * 
26.  * Copyright 2008 
27.  *
28.  * Licensed under the Apache License, Version 2.0 (the "License");
29.  * you may not use this file except in compliance with the License.
30.  * You may obtain a copy of the License at
31.  *
32.  * http://www.apache.org/licenses/LICENSE-2.0
33.  *
34.  * Unless required by applicable law or agreed to in writing, software
35.  * distributed under the License is distributed on an "AS IS" BASIS,
36.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
37.  * either express or implied. See the License for the specific language
38.  * governing permissions and limitations under the License.
39.  *
40.  * @project loonframework
41.  * @author chenpeng  
42.  * @email：[email protected] 
43.  * @version 0.1
44.  */
45. public class Keep {
46. 
    
47.     private static final long serialVersionUID = -1982090153295778606L;
48. 
    
49.     final static public String LS = System.getProperty("line.separator", "/n");
50. 
    
51.     final static public String FS = System.getProperty("file.separator", "//");
52.     
53.     /**
54.      * 增位变更指定字符串(混淆记录用)
55.      * 
56.      * @param s
57.      * @param x
58.      * @return
59.      */
60.     final static public String addChange(final String s, final int x) {
61.         String result = null;
62.         StringBuilder sbr = new StringBuilder();
63.         for (int i = 0; i < s.length(); i++) {
64.             char p = (char) (s.charAt(i) + x);
65.             sbr.append(p);
66.         }
67.         try {
68.             result = URLEncoder.encode(sbr.toString(),"UTF-8");
69.         } catch (UnsupportedEncodingException e) {
70.             throw new RuntimeException(e);
71.         }
72.         return result;
73.     }
74. 
    
75.     /**
76.      * 减位变更指定字符串(混淆记录用)
77.      * 
78.      * @param s
79.      * @param x
80.      * @return
81.      */
82.     final static public String backChange(final String s, final int x) {
83.         String result = null;
84.         try {
85.             result = URLDecoder.decode(s,"UTF-8");
86.         } catch (UnsupportedEncodingException e) {
87.             throw new RuntimeException(e);
88.         }
89.         StringBuilder sbr = new StringBuilder();
90.         for (int i = 0; i < result.length(); i++) {
91.             char p = (char) (result.charAt(i) - x);
92.             sbr.append(p);
93.         }
94.         return sbr.toString();
95.     }
96.     
97. 
    
98.     /**
99.      * 压缩byte[]
100.      * 
101.      * @param buffer
102.      * @return
103.      */
104.     public static byte[] compress(final byte[] buffer) {
105.         try {
106.             ByteArrayOutputStream baos = new ByteArrayOutputStream();
107.             GZIPOutputStream gzipos = new GZIPOutputStream(baos);
108.             gzipos.write(buffer);
109.             gzipos.flush();
110.             gzipos.close();
111.             return baos.toByteArray();
112.         } catch (IOException e) {
113.             return null;
114.         }
115.     }
116. 
     
117.     /**
118.      * 压缩byte[]
119.      * 
120.      * @param buffer
121.      * @return
122.      */
123.     public static byte[] uncompress(final byte[] buffer) {
124.         try {
125.             GZIPInputStream gzipis = new GZIPInputStream(
126.                     new ByteArrayInputStream(buffer));
127.             ByteArrayOutputStream baos = new ByteArrayOutputStream();
128.             byte[] tmp = new byte[8192];
129.             int len;
130.             while ((len = gzipis.read(tmp)) > 0) {
131.                 baos.write(tmp, 0, len);
132.             }
133.             baos.flush();
134.             return baos.toByteArray();
135.         } catch (IOException e) {
136.             return null;
137.         }
138.     }
139. 
     
140.     /**
141.      * 保存游戏记录
142.      * 
143.      * @param file
144.      * @param bytes
145.      * @throws IOException
146.      */
147.     public static void save(final String fileName,final String message) throws IOException {
148.         save(new File(fileName), new ByteArrayInputStream(Keep.compress(message.getBytes())));
149.     }
150. 
     
151.     /**
152.      * 保存记录到文件
153.      * 
154.      * @param file
155.      * @param input
156.      * @throws IOException
157.      */
158.     private static void save(final File file,final InputStream input)
159.             throws IOException {
160.         mkdirs(file);
161.         BufferedOutputStream output = null;
162.         try {
163.             int contentLength = input.available();
164.             output = new BufferedOutputStream(
165.                     new FileOutputStream(file, false));
166.             while (contentLength-- > 0) {
167.                 output.write(input.read());
168.             }
169.         } finally {
170.             close(input, file);
171.             close(output, file);
172.         }
173.     }
174.     
175.     final private static byte[] read(final InputStream inputStream) {
176.         byte[] arrayByte = null;
177.         BufferedInputStream buffer = new BufferedInputStream(inputStream);
178.         ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
179.         byte[] bytes = new byte[8192];
180.         try {
181.             int read;
182.             while ((read = buffer.read(bytes)) >= 0) {
183.                 byteArrayOutputStream.write(bytes, 0, read);
184.             }
185.             arrayByte = byteArrayOutputStream.toByteArray();
186.         } catch (IOException e) {
187.             throw new RuntimeException(e);
188.         } finally {
189.             try {
190.                 if (buffer != null) {
191.                     buffer.close();
192.                     buffer = null;
193.                 }
194.             } catch (IOException e) {
195.                 throw new RuntimeException(e);
196.             }
197.         }
198.         return Keep.uncompress(arrayByte);
199.     }
200. 
     
201.     /**
202.      * 读取记录到list
203.      * 
204.      * @param fileName
205.      * @return
206.      * @throws IOException
207.      */
208.     public static List load(final String fileName) throws IOException {
209.         File file = new File(fileName);
210.         BufferedReader reader = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(Keep.read(new FileInputStream(file)))));
211.         List records = new ArrayList();
212.         String record = null;
213.         try {
214.             while ((record = reader.readLine()) != null) {
215.                 records.add(record);
216.             }
217.         } finally {
218.             close(reader, file);
219.         }
220.         return records;
221.     }
222. 
     
223.     /**
224.      * 创建文件夹
225.      * 
226.      * @param file
227.      * @throws IOException
228.      */
229.     private static void mkdirs(final File file) throws IOException {
230.         checkFile(file);
231.         File parentFile = file.getParentFile();
232.         if (parentFile != null) {
233.             if (!parentFile.exists() && !parentFile.mkdirs()) {
234.                 throw new IOException("Creating directories "
235.                         + parentFile.getPath() + " failed.");
236.             }
237.         }
238.     }
239. 
     
240.     private static void checkFile(final File file) throws IOException {
241.         if (file.exists() && !file.isFile()) {
242.             throw new IOException("File " + file.getPath()
243.                     + " is actually not a file.");
244.         }
245.     }
246. 
     
247.     private static void close(final InputStream input,final File file) {
248.         if (input != null) {
249.             try {
250.                 input.close();
251.             } catch (IOException e) {
252.                 closingFailed(file, e);
253.             }
254.         }
255.     }
256. 
     
257.     private static void close(final OutputStream output,final File file) {
258.         if (output != null) {
259.             try {
260.                 output.close();
261.             } catch (IOException e) {
262.                 closingFailed(file, e);
263.             }
264.         }
265.     }
266. 
     
267.     private static void close(final Reader reader,final File file) {
268.         if (reader != null) {
269.             try {
270.                 reader.close();
271.             } catch (IOException e) {
272.                 closingFailed(file, e);
273.             }
274.         }
275.     }
276. 
     
277.     private static void closingFailed(final File file,final IOException e) {
278.         String message = "Closing file " + file.getPath() + " failed.";
279.         throw new RuntimeException(message + ":" + e.getMessage());
280.     }
281. 
     
282. }
283. 
     

导出的结果：

 

  比如在这个示例游戏中，我将保存的数据先递增字符位数，再经过URL编码，最后gzip压缩，出来的一组鬼画符般记录文档，唯一的作用就是不让人轻易读出并修改罢了。当然这只是最简单的例子，我们完全加密的更复杂（比如玩玩DES），验证的更变态，让玩家绞尽脑汁也无法修改游戏分毫，毕竟让玩家快乐且痛苦的游戏，就是游戏制作者最大的乐趣及兴奋点啊，哈哈哈。（惊见板砖+臭鸡蛋，我闪~~~）

主菜单界面：

  游戏基本界面，背景设定主角在一座城镇中，有五项基本命令可供选择。

 

  队友雇用界面：

  即酒店界面，用于寻找战友加入

 

  物品购入界面： 

  商店，用于补充游戏中物品

 

  物品装备界面：

  道具装备，用于装备购入的物品

 

  关卡选择界面：  

  任务选择，本示例由于没有考虑做大，所以直接将关卡做成赏金模式供玩家选择

  

   战斗画面：

   最初有过在此例复刻梦幻模拟战2的打算，但由于没有找到整套的素材，所以作罢。谁有兴趣帮兄弟找到整套素材（关键是各兵种战斗图）的话，我可以再作一个复刻梦幻2的例子。
 
  

  SLG游戏入门示例及源码下载地址：http://download.csdn.net/source/809105