如题，采用的是Sun Checks规范，

最终将代码修改如下：
增加了package-info.java文件
Cell.java
package lifegame;

/**Cell为细胞类，以实现数据封装和实现与细胞有关的方法.*/
public class Cell {
    /**长度.*/
    private int maxLength;
    /**宽度.*/
    private int maxWidth;
    /**当前代数.*/
    private int nowGeneration;
    /**一个数据代表一个细胞,0代表死，1代表活.*/
    private int[][] grid;

    /**
     * Cell类的构造函数.
     * @param maxLen 形参：长度
     * @param maxWid 形参：宽度
     * */
    public Cell(final int maxLen, final int maxWid) {
        maxLength = maxLen;
        maxWidth = maxWid;
        nowGeneration = 0;
        grid = new int[maxLen + 2][maxWid + 2];
        for (int i = 0; i <= maxLen + 1; i++) {
            for (int j = 0; j <= maxWid + 1; j++) {
                grid[i][j] = 0;
            }
        }
    }

    /**
     * 实现数据封装.
     * @param g 形参：细胞
     */
    public void setGrid(final int[][] g) {
        grid = g;
    }

    /**
     * 实现数据封装.
     * @return 细胞
     */
    public int[][] getGrid() {
        return grid;
    }

    /**
     * 实现数据封装.
     * @param nowGen 形参：当前代数
     */
    public void setNowGeneration(final int nowGen) {
        nowGeneration = nowGen;
    }

    /**
     * 实现数据封装.
     * @return 当前代数
     */
    public int getNowGeneration() {
        return nowGeneration;
    }

    /**随机初始化细胞.*/
    public void randomCell() {
        final double p = 0.5; //细胞随机初始化为活的概率
        for (int i = 1; i <= maxLength; i++) {
            for (int j = 1; j <= maxWidth; j++) {
                grid[i][j] = Math.random() > p ? 1 : 0;
            }
        }
    }

    /**细胞清零.*/
    public void deleteAllCell() {
        for (int i = 1; i <= maxLength; i++) {
            for (int j = 1; j <= maxWidth; j++) {
                grid[i][j] = 0;
            }
        }
    }

    /**繁衍.*/
    public void update() {
        int[][] newGrid = new int[maxLength + 2][maxWidth + 2];
        for (int i = 1; i <= maxLength; i++) {
            final int x = 3; //细胞为活的邻居数量
            for (int j = 1; j <= maxWidth; j++) {
                switch (getNeighborCount(i, j)) {
                    case 2:
                        newGrid[i][j] = grid[i][j]; //细胞状态保持不变
                        break;
                    case x:
                        newGrid[i][j] = 1; // 细胞置为活
                        break;
                    default:
                        newGrid[i][j] = 0; // 细胞置为死
                }
            }
        }
        for (int i = 1; i <= maxLength; i++) {
            for (int j = 1; j <= maxWidth; j++) {
                grid[i][j] = newGrid[i][j];
            }
        }
        nowGeneration++;
    }

    /**
     * 获取细胞的邻居数量.
     * @return 细胞邻居数量
     * @param i1  行
     * @param j1  列
     */
    private int getNeighborCount(final int i1, final int j1) {
        int count = 0;
        for (int i = i1 - 1; i <= i1 + 1; i++) {
            for (int j = j1 - 1; j <= j1 + 1; j++) {
                count += grid[i][j]; //如果邻居还活着，邻居数便会+1
            }
        }
        count -= grid[i1][j1]; //每个细胞不是自己的邻居，则如果细胞还活着，邻居数-1.
        return count;
    }
}


GUI.java
package lifegame;

import javax.swing.JFrame;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JPanel;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import java.awt.BorderLayout;
import java.awt.GridLayout;
import java.awt.Color;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.event.ActionEvent;

/**GUI为细胞类，以调用细胞类的方法和实现生命游戏过程的可视化.*/
public class GUI extends JFrame implements ActionListener {
    /**界面.*/
    private static GUI frame;
    /**细胞.*/
    private Cell cell;
    /**长和宽.*/
    private int maxLength, maxWidth;
    /**一个按钮表示一个细胞.*/
    private JButton[][] nGrid;
    /**按钮是否被选中.*/
    private boolean[][] isSelected;
    /**确定，当前代数，代数清零.*/
    private JButton ok, jbNowGeneration, randomInit, clearGeneration;
    /**下一代，开始繁衍，暂停，退出.*/
    private JButton clearCell, nextGeneration, start, stop, exit;
    /**长宽选择.*/
    private JComboBox lengthList, widthList;
    /**线程.*/
    private Thread thread;
    /**线程是否在运行.*/
    private boolean isRunning;
    /**细胞是否死亡.*/
    private boolean isDead;

    /**
     * 程序入口.
     * @param args 接收命令行参数
     */
    public static void main(final String[] args) {
        frame = new GUI("生命游戏");
    }

    /**
     * 实现数据封装.
     * @return 宽度
     */
    public int getMaxWidth() {
        return maxWidth;
    }

    /**
     * 实现数据封装.
     * @param maxWid 宽度
     */
    public void setMaxWidth(final int maxWid) {
        this.maxWidth = maxWid;
    }

    /**
     * 实现数据封装.
     * @return 长度
     */
    public int getMaxLength() {
        return maxLength;
    }

    /**
     * 实现数据封装.
     * @param maxLen 宽度
     */
    public void setMaxLength(final int maxLen) {
        this.maxLength = maxLen;
    }

    /**初始化界面.*/
    public void initGUI() {
        final int wid = 20; //界面默认的宽度
        final int len = 35; //界面默认的长度
        if (maxWidth == 0) {
            maxWidth = wid;
        }
        if (maxLength == 0) {
            maxLength = len;
        }

        cell = new Cell(maxWidth, maxLength);

        JPanel backPanel, centerPanel, bottomPanel;
        JLabel jWidth, jLength, jNowGeneration;
        backPanel = new JPanel(new BorderLayout());
        centerPanel = new JPanel(new GridLayout(maxWidth, maxLength));
        bottomPanel = new JPanel();
        this.setContentPane(backPanel);
        backPanel.add(centerPanel, "Center");
        backPanel.add(bottomPanel, "South");

        nGrid = new JButton[maxWidth][maxLength];
        isSelected = new boolean[maxWidth][maxLength];
        for (int i = 0; i < maxWidth; i++) {
            for (int j = 0; j < maxLength; j++) {
                nGrid[i][j] = new JButton(""); //按钮内容置空以表示细胞
                nGrid[i][j].setBackground(Color.WHITE); //初始时所有细胞均为死
                centerPanel.add(nGrid[i][j]);
            }
        }
        final int minNum = 3; //长宽最小值
        final int maxNum = 100; //长宽最大值
        jLength = new JLabel("长度：");
        lengthList = new JComboBox();
        for (int i = minNum; i <= maxNum; i++) {
            lengthList.addItem(String.valueOf(i));
        }
        lengthList.setSelectedIndex(maxLength - minNum);

        jWidth = new JLabel("宽度：");
        widthList = new JComboBox();
        for (int i = minNum; i <= maxNum; i++) {
            widthList.addItem(String.valueOf(i));
        }
        widthList.setSelectedIndex(maxWidth - minNum);

        ok = new JButton("确定");
        jNowGeneration = new JLabel(" 当前代数：");
        //button按钮不能直接添加int，故采用此方式
        jbNowGeneration = new JButton("" + cell.getNowGeneration());
        jbNowGeneration.setEnabled(false);
        clearGeneration = new JButton("代数清零");
        randomInit = new JButton("随机初始化");
        clearCell = new JButton("细胞清零");
        start = new JButton("开始繁衍");
        nextGeneration = new JButton("下一代");
        stop = new JButton("暂停");
        exit = new JButton("退出");

        bottomPanel.add(jLength);
        bottomPanel.add(lengthList);
        bottomPanel.add(jWidth);
        bottomPanel.add(widthList);
        bottomPanel.add(ok);
        bottomPanel.add(jNowGeneration);
        bottomPanel.add(jbNowGeneration);
        bottomPanel.add(clearGeneration);
        bottomPanel.add(randomInit);
        bottomPanel.add(clearCell);
        bottomPanel.add(start);
        bottomPanel.add(nextGeneration);
        bottomPanel.add(stop);
        bottomPanel.add(exit);


        // 设置窗口
        final int length = 1000; //界面长度
        final int height = 650; //界面宽度
        this.setSize(length, height);
        this.setResizable(true);
        this.setLocationRelativeTo(null); // 让窗口在屏幕居中
        this.setVisible(true); // 将窗口设置为可见的

        // 注册监听器
        this.addWindowListener(new WindowAdapter() {
            public void windowClosed(final WindowEvent e) {
                System.exit(0);
            }
        });
        ok.addActionListener(this);
        clearGeneration.addActionListener(this);
        randomInit.addActionListener(this);
        clearCell.addActionListener(this);
        nextGeneration.addActionListener(this);
        start.addActionListener(this);
        stop.addActionListener(this);
        exit.addActionListener(this);
        for (int i = 0; i < maxWidth; i++) {
            for (int j = 0; j < maxLength; j++) {
                nGrid[i][j].addActionListener(this);
            }
        }
    }

    /**
     * 新建界面.
     * @param name  界面标题
     */
    public GUI(final String name) {
        super(name);
        initGUI();
    }

    /**
     * 接收操作事件.
     * @param e 操作事件
     */
    public void actionPerformed(final ActionEvent e) {
        final int minNum = 3; //长宽最小值
        final int sleeptime = 500; //线程睡眠的时间数
        if (e.getSource() == ok) { //确定
            frame.setMaxLength(lengthList.getSelectedIndex() + minNum);
            frame.setMaxWidth(widthList.getSelectedIndex() + minNum);
            initGUI();

            cell = new Cell(getMaxWidth(), getMaxLength());

        } else if (e.getSource() == clearGeneration) { //代数清零
            cell.setNowGeneration(0);
            jbNowGeneration.setText("" + cell.getNowGeneration()); //刷新当前代数
            isRunning = false;
            thread = null;
        } else if (e.getSource() == randomInit) { //随机初始化
            cell.randomCell();
            showCell();
            isRunning = false;
            thread = null;
        } else if (e.getSource() == clearCell) { //细胞清零
            cell.deleteAllCell();
            showCell();
            isRunning = false;
            thread = null;
        } else if (e.getSource() == start) { //开始
            isRunning = true;
            thread = new Thread(new Runnable() {
                public void run() {
                    while (isRunning) {
                        makeNextGeneration();
                        try {
                            Thread.sleep(sleeptime);
                        } catch (InterruptedException e1) {
                            e1.printStackTrace();
                        }
                        isDead = true;
                        for (int row = 1; row <= maxWidth; row++) {
                            for (int col = 1; col <= maxLength; col++) {
                                if (cell.getGrid()[row][col] != 0) {
                                    isDead = false;
                                    break;
                                }
                            }
                            if (!isDead) {
                                break;
                            }
                        }
                        if (isDead) {
                            JOptionPane.showMessageDialog(null, "所有细胞已死亡");
                            isRunning = false;
                            thread = null;
                        }
                    }
                }
            });
            thread.start();
        } else if (e.getSource() == nextGeneration) { //下一代
            makeNextGeneration();
            isRunning = false;
            thread = null;
        } else if (e.getSource() == stop) { //暂停
            isRunning = false;
            thread = null;
        } else if (e.getSource() == exit) { //退出
            frame.dispose();
            System.exit(0);
        } else {
            int[][] grid = cell.getGrid();
            for (int i = 0; i < maxWidth; i++) {
                for (int j = 0; j < maxLength; j++) {
                    if (e.getSource() == nGrid[i][j]) {
                        isSelected[i][j] = !isSelected[i][j];
                        if (isSelected[i][j]) {
                            nGrid[i][j].setBackground(Color.BLACK);
                            grid[i + 1][j + 1] = 1;
                        } else {
                            nGrid[i][j].setBackground(Color.WHITE);
                            grid[i + 1][j + 1] = 0;
                        }
                        break;
                    }
                }
            }
            cell.setGrid(grid);
        }
    }

    /**下一代.*/
    private void makeNextGeneration() {
        cell.update();
        showCell();
        jbNowGeneration.setText("" + cell.getNowGeneration()); //刷新当前代数
    }

    /**将细胞加载到界面上.*/
    public void showCell() {
        int[][] grid = cell.getGrid();
        for (int i = 0; i < maxWidth; i++) {
            for (int j = 0; j < maxLength; j++) {
                if (grid[i + 1][j + 1] == 1) {
                    nGrid[i][j].setBackground(Color.BLACK); //活显示黑色
                } else {
                    nGrid[i][j].setBackground(Color.WHITE); //死则显示白色
                }
            }
        }
    }

}

主要软件
1.UnityStudio  用于解包资源

2.DNSPY 用于反编译代码并进行修改

3.ILSPY 同上，差不多功能
资源部份
下面拿steam游戏《传说法师》作为例子进行解包。

游戏资源可以使用UnityStudio软件获取。如果是安卓包可以将后缀改为.zip解压出文件夹。首先选择File->Load folder->游戏目录



然后我们就可以预览资源了，并且可以导出想要的资源。




代码部分
这里使用的DNSPY软件。首先用软件打开游戏目录下Managed文件夹下的Assembly-CSharp.dll文件。





然后我们就可以在如下图所示的路径中查看到游戏的所有代码。



并且我们可以通过右键目标类进行编辑。编辑后选择编译按钮即可。





最后选择保存模块即可生效。

弹出面板无需更改选项，直接点击确认。





ILSPY和DNSPY功能类似，不过我只用过反编译代码没有修改过，有兴趣的朋友可以研究下。
最终效果
通过上面修改源码后可以发现我们的初始技能改变了。

    
该软件的特点是能够通过配置选项来生成对应的代码跟配置文件。
界面使用duilib
1、树形控件的使用。该控件是参照例子的游戏大厅的树形控件进行修改。
    树形控件是继承自CListUI空间，也就是说其实树形控件的每一行都是使用列表列出。这里使用的是html的方式进行显示。
    在初始化的时候将所有的选项都放入listui中，然后基于“父节点”进行判断是隐藏还是显示，通过SetInternVisible来设置，起初我使用的是SetVisible的方式发现不起作用，最终使用该方式了。我起初选择setvisible的原因是我看到Getvisible是俩变量全为真才返回真。在发现不行的时候，看了下，发现setvisible初始化都是true，除非在xml中特别声明，而intervisible却是在构造函数中直接初始化为true.但是具体为什么，需要路过的大神指点迷津。
 
2、在设计上面，置给树形控件的数据也是额外创建了一棵树，然后在树形控件点击选择对应哪个节点，然后在额外的树上进行修改，将结果给treeview显示。这样实现逻辑跟视图的分开。 这样做也有一个好处就是在后期可能会支持命令行的方式直接配置，而不是显示界面再配置。
3、在文件的路径判断上面使用了谷歌的base库的判断方式，来判断当前路径是否是绝对路径。然后分隔符也使用base库的方式，搞成数组，再遍历数组每个分隔符。具体参考file_util文件。
4、计算数组的方式使用自己写的ArraySize，这里也借鉴了base的Arraysize，起初不理解为何这样做可以，后来发现sizeof()在编译期就已经确定了，所以不去管你声明的函数具体有没有实现。其实可以做这样一个测试。int a = 0; sizeof(++a); print(a) 会发现a 还是显示0.
template<typename T, unsigned int N>
char (&ArraySizeHelper (T (&)[N]))[N];
#define ArraySize(array) (sizeof(ArraySizeHelper(array)))
 
5、在点击弹出一个对话框，然后可以在里面选择文件或者文件夹这里，可以参照window程序设计里面的GetOpenFileName 和 GetSaveFileName来操作。
在这里返回的文件名时，可以使用::FindFirstFile等对应的一系列函数（可以通过msdn）进行查找。记住这里有一个地方，在查找到的文件夹的时候会返回. 或者..这样的路径。这里需要过滤掉，否则在路径递归的过程中会出现死循环的情况。
有时候创建的时候输进来的是路径不存在的文件，择需要使用CreateDirectory进行文件夹的创建。

转载于:https://www.cnblogs.com/cxiaoln/p/4091443.html

作业要求：
step 1： fork 老师的仓库
+硬币游戏：http://git.oschina.net/juking2017/Game.git 将其 fork 到你的码云仓库。
step2：clone 到本地，修改后 push 到你的远端仓库
将你的仓库Game.git clone到本地, 运行Python 程序，截图。
【必做】学习 Python 编码风格指南中译版（Google SOC）; 依据代码规范改进代码。
【选做】提出游戏规则修改（优化）建议，并修改程序，运行截图（用于写博客）。
将你的修改commit 并 push 到你远端的仓库。git 命令可参考 附加题2
step3: 写博客。
1.说明你的游戏规则，并陈述你（慈善长久不衰）的理由, 附上截图。
2.博客中附上程序代码，重点：陈述你代码改进部分。
3.给出你远端仓库的链接。
作业记录如下：
1.登陆码云，打开连接http://git.oschina.net/juking2017/Game.git，点击屏幕右上角的fork。

2.在桌面新建一个文件夹“新建文件夹”，将码云上的项目clone。
 （文件夹内右键“Git Bash Here”,在其中键入git clone https://gitee.com/Justso111/Game）
3.下载安装python后打开Game，运行程序，发现缺少模块“numpy”。
   故安装此模块，先输入pip install numpy,再输入pip install matplotlib进行升级。

4.使用IDLE打开clone到桌面的GameMain.

运行该程序如下：


5.修改代码风格
①import按照从最常用到最不常用的顺序分组放置，即import标准库在前，import第三方库在后，此外要按照字母顺序排序，且所有以from...开头的行都应靠前，然后是一个空行，再然后是所有以import...开头的行。

②二元运算符（包括：赋值、比较等）需要在两边加空格，指名参数或默认参数值两边不要加空格。

③逗号后面必须加空格，为此在代码中的逗号后面加入空格。

6.将修改commit 并 push 到远端的仓库
 我的远端仓库链接是：https://gitee.com/Justso111/Game/commit/ad9c637dafd0256742f62ba41533137da85a3080
转载于:https://www.cnblogs.com/Justso111/p/7603208.html