由 北大青鸟（骑士飞行棋）Demo 联想到了地图中的河流、路线绘制

 

--startGame类

public class StartGame {

    /**

     * 启动游戏

     * @param args

     */

    public static void main(String[] args) {

       Game game = new Game();   //创建游戏类

        game.start();             //开始游戏

    }

}

 

--Game类

import java.util.*;

public class Game {

      Map map;  //地图

      int playerPos1; //对战中玩家1的当前位置

      int playerPos2; //对战中玩家2的当前位置

      String[] goAndStop = new String[2];   //走或停标识设置

      String[] playerName = new String[2];  //对战角色

     

      /**

       * 初始化游戏的一局

       */

      public void init(){  

          map = new Map();

          map.createMap();  //生成地图

           playerPos1 = 0;   //设置玩家1起始位置

           playerPos2 = 0;   //设置玩家2起始位置

           goAndStop[0] = "on";  //记录玩家1下一次走或停

           goAndStop[1] = "on";  //设置玩家2下一次走或停

      }

     

     

      /**

       * 开始游戏

       */

      public void start(){

          //初始化

          init(); 

      System.out.println("※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※");

      System.out.println("//                                                //");

      System.out.println("//                                                //");

      System.out.println("//             骑    士    飞    行    棋               //");

      System.out.println("//                                                //");

      System.out.println("//                                                //");

      System.out.println("※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※※\n\n\n");

      

      

      System.out.println("\n~~~~~~~~~~~~~~~~~~~两  人  对  战~~~~~~~~~~~~~~~~~~~");

      System.out.println("\n请选择角色: 1. 戴高乐 2. 艾森豪威尔 3. 麦克阿瑟 4. 巴顿");

      Scanner input = new Scanner(System.in);

      System.out.print("请玩家1选择角色:  ");

      int role1 = input.nextInt();

          int role2;

          do{

          System.out.print("请玩家2选择角色： ");

              role2 = input.nextInt();  //双方选择角色代号

          }while(role2==role1);  //不允许角色重复

          setRole(1, role1);   //设置玩家1代表的角色

          setRole(2, role2);   //设置玩家2代表的角色    

          play();   //开始两人对战

      }

     

      /**

       * 设置对战角色

       * @param no 玩家次序 1：玩家1 2：玩家2

       * @param role 角色代号

       */

      public void setRole(int no,int role){

      switch(role){

          case 1:

              playerName[no-1] = "戴高乐";

              break;

          case 2:

              playerName[no-1] = "艾森豪威尔";

              break;

          case 3:

              playerName[no-1] = "麦克阿瑟";

              break;

          case 4:

              playerName[no-1] = "巴顿";

              break;

          default:

              break;

      }

      }

     

     

      /**

       * 两人对战玩法

       */

      public void play(){  

          System.out.println("\n\n\n\n");

         

      System.out.print("\n\n****************************************************\n");

      System.out.print("                     Game  Start                    \n");

      System.out.print("****************************************************\n\n");

      

      //显示对战双方士兵样式

      System.out.println("^_^" + playerName[0] + "的士兵：　Ａ");

      System.out.println("^_^" + playerName[1] + "的士兵：  Ｂ\n");

         

      //显示对战地图

      System.out.println("\n图例： " + "■ 暂停  ¡è 幸运轮盘   ★ 地雷   〓 时空隧道   ∷ 普通\n");

         

          map.showMap(playerPos1, playerPos2);

         

         

      //游戏开始

      int step;  //存储骰子数目

          while(playerPos1 < 99 && playerPos2 < 99){   //有任何一方走到终点，跳出循环

          

          //轮流掷骰子

          if(goAndStop[0].equals("on")){   

                  //玩家1掷骰子

                step = throwShifter(1);   //掷骰子

                System.out.println("\n-----------------");  //显示结果信息

               System.out.println("骰子数： "+ step);

               playerPos1 = getCurPos(1, playerPos1, step);   //计算这一次移动后的当前位置

               System.out.println("\n您当前位置：  "+ playerPos1);

               System.out.println("对方当前位置："+ playerPos2);

               System.out.println("-----------------\n");

               map.showMap(playerPos1, playerPos2); //显示当前地图

               if(playerPos1 == 99){  //如果走到终点

                   break;   //退出

                }

          }else{

              System.out.println("\n" + playerName[0] +"停掷一次！\n");   //显示此次暂停信息

              goAndStop[0] = "on";   //设置下次可掷状态

          }

 

          

              System.out.println("\n\n\n\n");

          

          if(goAndStop[1].equals("on")){

                  //玩家2掷骰子

               step = throwShifter(2); //掷骰子

               System.out.println("\n-----------------"); //显示结果信息

               System.out.println("骰子数： "+ step);

               playerPos2 = getCurPos(2, playerPos2, step);   //计算这一次移动后的当前位置

               System.out.println("\n您当前位置：  "+ playerPos2);

               System.out.println("对方当前位置："+ playerPos1);

               System.out.println("-----------------\n");

               map.showMap(playerPos1, playerPos2);

               if(playerPos2 == 99){  //如果走到终点

                   break;   //退出

                }

          }else{

              System.out.println("\n" + playerName[1] + "停掷一次！\n");  //显示此次暂停信息

              goAndStop[1] = "on";  //设置下次可掷状态

          }

 

          System.out.println("\n\n\n\n");

      }

         

          //游戏结束

          System.out.println("\n\n\n\n");

          System.out.print("****************************************************\n");

      System.out.print("                      Game  Over                    \n");

      System.out.print("****************************************************\n\n");

          judge();

      }

     

     

      /**

       * 掷骰子

       * @param no 玩家次序

       * @return step 掷出的骰子数目

       */

      public int throwShifter(int no){

      int step = 0; 

      System.out.print("\n\n" + playerName[no-1] + ", 请您按任意字母键后回车启动掷骰子： ");

      Scanner input = new Scanner(System.in);

      String answer = input.next();

          step = (int)(Math.random()*10) % 6 + 1;   //产生一个1~6的数字,即掷的骰子数目

      return step;

      }

     

 

     

      /**

       * 计算玩家此次移动后的当前位置

       * @param no 玩家次序

       * @param position 移动前位置

       * @param step 掷的骰子数目

       * @return position 移动后的位置

       */

      public int getCurPos(int no,int position,int step){

      position = position + step;  //第一次移动后的位置

      if(position >= 99){

          return 99;

      }

      Scanner input = new Scanner(System.in);

      switch(map.map[position]){   //根据地图中的关卡代号进行判断

         case 0:    //走到普通格

          if(no ==1 && playerPos2 == position){   //玩家1与对方骑兵相遇

             playerPos2 = 0;    //踩到对方，对方回到起点

             System.out.println(":-D  哈哈哈哈...踩到了！");

          }

          if (no == 2 && playerPos1 == position){ //玩家2与对方骑兵相遇

             playerPos1 = 0;    //踩到对方，对方回到起点

             System.out.println(":-D  哈哈哈哈...踩到了！");

          }

             break;

             case 1:   //幸运轮盘

             System.out.println("\n◆◇◆◇◆欢迎进入幸运轮盘◆◇◆◇◆");

             System.out.println("   请选择一种运气：");

             System.out.println("   1. 交换位置  2. 轰炸");

             System.out.println("=============================\n");

             int choice  = input.nextInt();

             int temp;

             switch(choice){

                 case 1:

                  if(no == 1){

                      temp = position;

                         position = playerPos2;

                         playerPos2 = temp;

                  }else if(no == 2){

                      temp = position;

                         position = playerPos1;

                         playerPos1 = temp;

                  }

                  break;

                 case 2:

                  if(no == 1 && playerPos2 < 6){

                      playerPos2 = 0;

                  }else{

                      playerPos2 = playerPos2 - 6;

                  }

                  if(no == 2 && playerPos2 < 6){

                      playerPos1 = 0;

                  }else{

                      playerPos1 = playerPos1 - 6;

                  }

                  break;

             }

             //System.out.println(":~)  " + "幸福的我都要哭了...");

             break;

            case 2:   //踩到地雷

            position = position -6; //踩到地雷退6步

            System.out.println("~:-(  " + "踩到地雷，气死了...");

            break;

            case 3:  //下一次暂停一次

            goAndStop[no-1] = "off";  //设置下次暂停掷骰子

            System.out.println("~~>_<~~  要停战一局了。");

            break;

            case 4:   //时空隧道

                position = position + 10;  //进入时空隧道，加走10步

                System.out.println("|-P  " + "进入时空隧道， 真爽！");

                break;

      }

      

      //返回此次掷骰子后玩家的位置坐标   

      if(position < 0){

          return 0;

      }else if(position > 99){

          return 99;

      }else{

          return position;

      }

      }

     

      /**

       * 显示对战结果

       */

      public void judge(){

      if(playerPos1 > playerPos2){

          System.out.println("\n恭喜" + playerName[0] + "将军! 您获胜了！");

      }else{

          System.out.println("\n恭喜" + playerName[1] + "将军! 您获胜了！");

      }

      }

}

 

 

--Map类

public class Map {

    int[] map = new int[100];   //对战地图

    int[] luckyTurn = {6, 23, 40, 55, 69, 83}; //幸运轮盘

    int[] landMine = {5, 13, 17, 33, 38, 50, 64, 80, 94};   //地雷位置

    int[] pause = {9, 27, 60, 93};         //暂停

    int[] timeTunnel = {20, 25, 45, 63, 72, 88, 90};   //时空隧道

 

   

     /**

       * 生成地图:

       * 关卡代号为：1：幸运轮盘 2：地雷  3: 暂停 4：时空隧道 0：普通

       */

    public void createMap(){

        int i = 0;

        

        //在对战地图上设置幸运轮盘

        for(i = 0; i < luckyTurn.length; i++){

         map[luckyTurn[i]] = 1;

        }

        

        //在对战地图上设置地雷

        for(i = 0; i < landMine.length; i++){

        map[landMine[i]] = 2;

        }

        

        //在对战地图上设置暂停

        for(i = 0; i < pause.length; i++){

        map[pause[i]] = 3;

        }

        

        //在对战地图上设置时空隧道

        for(i = 0; i < timeTunnel.length; i++){

        map[timeTunnel[i]] = 4;

        }

    }

   

    /**

     * 显示地图关卡对应的图形

     * @param i 地图当前位置的关卡代号

     * @param index 当前地图位置编号

     * @param playerPos1 玩家1的当前位置

     * @param playerPos2 玩家2的当前位置

     * @return 地图当前位置的对应图片

     */

    public String getGraph(int i,int index,int playerPos1,int playerPos2){

    String graph = "";

    if(index == playerPos1 && index== playerPos2){

        graph = "@@";

    }else if(index == playerPos1){ 

        //graph = "♀";

        graph = "Ａ";

        }else if(index == playerPos2){

        //graph = "♂";

        graph = "Ｂ";

        }else{

          switch(i){

       case 1:   //幸运轮盘

           graph = "¡è";

           break;

       case 2:   //地雷

           graph = "★";

           break;

       case 3:   //暂停

           graph = "■";

           break;

       case 4:   //时光隧道

           graph = "〓";

           break;

       default:

           graph = "∷";

           break;

        }

        }

    return graph;

    }

   

    /**

     * 输出地图的奇数行（第1、3行）

     * @param start 输出的起始点在地图上的位置

     * @param end  输出的结束点在地图上的位置

     * @param playerPos1 玩家1的当前位置

     * @param playerPos2 玩家2的当前位置

     */

    public void showLine1(int start,int end,int playerPos1,int playerPos2){    

    for(int i = start; i < end; i++){

        System.out.print(getGraph(map[i], i, playerPos1, playerPos2));

    }

    }

   

    /**

     * 输出地图的偶数行（第2行）

     * @param start 输出的起始点在地图上的位置

     * @param end  输出的结束点在地图上的位置

     * @param playerPos1 玩家1的当前位置

     * @param playerPos2 玩家2的当前位置

     */

    public void showLine2(int start,int end,int playerPos1,int playerPos2){   

    for(int i = end-1; i >= start; i-- ){ 

        System.out.print(getGraph(map[i], i,playerPos1, playerPos2));

    }

    }

   

    /**

     * 输出地图的右竖列

     * @param start 输出的起始点在地图上的位置

     * @param end  输出的结束点在地图上的位置

     * @param playerPos1 玩家1的当前位置

     * @param playerPos2 玩家2的当前位置

     */

    public void showRLine(int start,int end,int playerPos1,int playerPos2){

    for(int i = start; i< end; i++){

       for(int j = 28; j > 0; j--){  //输出29个空格

           System.out.print("  ");

       }

       System.out.print(getGraph(map[i], i,playerPos1, playerPos2));

       System.out.println();

    }

    }

   

    /**

     * 输出地图的左竖列

     * @param start 输出的起始点在地图上的位置

     * @param end  输出的结束点在地图上的位置

     * @param playerPos1 玩家1的当前位置

     * @param playerPos2 玩家2的当前位置

     */

    public void showLLine(int start,int end,int playerPos1,int playerPos2){

    for(int i = start; i < end; i++){

        System.out.println(getGraph(map[i], i,playerPos1, playerPos2));

    }

    }

 

    /**

     * 显示对战地图

     * @param playerPos1 玩家1的当前位置

     * @param playerPos2 玩家2的当前位置

     */

    public void showMap(int playerPos1,int playerPos2){

    showLine1(0, 31, playerPos1, playerPos2);   //显示地图第一行

    System.out.println();                     //换行

    showRLine(31,35, playerPos1, playerPos2);  //显示地图右竖行

    showLine2(35, 66, playerPos1, playerPos2); //显示地图第二行

    System.out.println();                     //换行

    showLLine(66, 69, playerPos1, playerPos2); //显示地图左竖行

        showLine2(69, 100, playerPos1, playerPos2); //显示地图第3行

    } 

}

 

从北大青鸟课件中得到的启发，今天无意中看到了这个小示例，虽然简单，但感觉代码逻辑值得借鉴。

图例： ■ 暂停  ¡è 幸运轮盘   ★ 地雷   〓 时空隧道   ∷ 普通

 

@@∷∷∷∷★¡è∷∷■∷∷∷★∷∷∷★∷∷〓∷∷¡è∷〓∷■∷∷∷

                                                                                                                      ∷

                                                                                                                      ∷

                                                                                                                      ★

                                                                                                                      ∷

∷★〓∷∷■∷∷∷∷¡è∷∷∷∷★∷∷∷∷〓∷∷∷∷¡è∷★∷∷∷

∷

∷

∷

∷∷∷∷∷★■∷∷〓∷〓∷∷∷∷¡è∷∷★∷∷∷∷∷∷∷〓∷∷¡è

要是自己的话可以先想想，自己如何绘制该图形。

 

同时，通过该示例得到了一个启发： 就是在做射击类的游戏时，可以先定义好精灵行走的路线，然后根据路线来改变精灵的当前坐标，这样就看起来精灵像是在道路（河流）中行走而不会出来。以下是自己写的一个小示例：

package riverRun;

 

import java.awt.Color;

import java.awt.Frame;

import java.awt.Graphics;

import java.awt.Image;

import java.awt.event.WindowAdapter;

import java.awt.event.WindowEvent;

 

public class RiverRunApp extends Frame {

    public static final int MAP_WIDTH = 800;

    public static final int MAP_HEIGHT = 600;

    private Image offScreenImage = null;

    private Map map = null; // 绘制地图

 

    public RiverRunApp() {

       map = new Map();

    }

 

    public static void main(String[] args) {

       RiverRunApp app = new RiverRunApp();

       app.lauchFrame();

    }

 

    /** 初始化窗体信息 */

    private void lauchFrame() {

       this.setTitle("精灵沿指定路线行走");

       this.setSize(MAP_WIDTH, MAP_HEIGHT);

       this.setResizable(false); // 是否可以调整大小

       this.setBackground(new Color(187, 201, 229));

       this.setVisible(true);

       this.setLocation(800, 500);

       new Thread(new ThreadPaint()).start();

       this.addWindowListener(new WindowAdapter() {

           public void windowClosing(WindowEvent e) {

              System.exit(0);

           }

       });

    }

 

    /** 重绘屏幕 */

 

    class ThreadPaint implements Runnable {

       @Override

       public void run() {

           while (true) {

              try {

                  Thread.sleep(41);

                  repaint();

              } catch (InterruptedException e) {

                  e.printStackTrace();

              }

           }

       }

    }

 

    public void paint(Graphics g) {

       map.draw(g);

    }

 

    /** 加入缓冲区 */

 

    public void update(Graphics g) {

       if (offScreenImage == null) {

           offScreenImage = this.createImage(MAP_WIDTH,MAP_HEIGHT);

       }

       Graphics gOffScreen = offScreenImage.getGraphics();

       Color c = gOffScreen.getColor();

       gOffScreen.setColor(new Color(187, 201, 229));

       gOffScreen.fillRect(0, 0, MAP_WIDTH, MAP_HEIGHT);

       gOffScreen.setColor(c);

       this.paint(gOffScreen);

       g.drawImage(offScreenImage, 0, 0, null);

    }

}

==========================

package riverRun;


import java.awt.Graphics;
/**
 * 显示抽象类
 */
public abstract class ShowEntity {
/**绘制抽象方法*/
protected abstract void draw(Graphics g);
}

===================================

package riverRun;

 

import java.awt.Color;

import java.awt.Graphics;

/**

 * 地图类

 */

public class Map {

    public static final int row = RiverRunApp.MAP_HEIGHT / Grid.GRID_HEIGHT;

    public static final int cell =  RiverRunApp.MAP_WIDTH / Grid.GRID_WIDTH;

    private ShowEntity hero = null;

    private ShowEntity grid = null;

    private int[][] maps = new int[row][cell];           //地图网格

    //河流行走的路线

    private int[][] riverRoadLine = new int[][]{{3,0},{3,1},{3,2}, {3,3},{3,4},{3,5},   //第一横行

                                          {4,5},{5,5},{6,5},                     //右边竖行

                                          {6,4},{6,3},{6,2},                     //第二横行

                                          {7,2},{8,2},{9,2},{10,2},              //左边竖行

                                          {11,2},{11,3},{11,4},{11,5},{11,6},{11,7},{11,8},{11,9},{11,10}};     //第三横行

   

    public Map(){

       initMapInfo();

       hero = new Hero(riverRoadLine);

       grid = new Grid();

      

       System.out.println("初始化地图信息");

    }

 

    /**初始化地图信息*/

    private void initMapInfo() {

       for(int i = 0; i < riverRoadLine.length; i++){

           for(int j = 0; j < riverRoadLine[0].length; j++){

              int m = riverRoadLine[i][0];

              int n = riverRoadLine[i][1];

              maps[m][n] = 1;

           }

       }

    }

 

    public void draw(Graphics g){

       System.out.println("绘制地图");

       for(int i = 0; i < row; i++){

           for(int j = 0; j < cell; j++){

              switch(maps[i][j]){

                  case 0:    //土地

                     g.setColor(Color.RED);

                     break;

                  case 1:    //河流

                     g.setColor(Color.GREEN);

                     break;

              }

              g.fill3DRect(j * Grid.GRID_WIDTH, i * Grid.GRID_HEIGHT, Grid.GRID_WIDTH, Grid.GRID_HEIGHT,false);

           }

       }

       grid.draw(g);

       hero.draw(g);

    }

}

==========================================

package riverRun;

import java.awt.Graphics;

/**

 * 格子

 */

public class Grid extends ShowEntity{

 

    public static final int GRID_WIDTH = 40;  //宽度

    public static final int GRID_HEIGHT = 40; //高度

   

    public Grid(){

       System.out.println("初始化格子构造方法");

    }

   

    @Override

    protected void draw(Graphics g) {

       System.out.println("绘制格子");

    }

 

}

============================================

package riverRun;

 

import java.awt.Color;

import java.awt.Graphics;

/**

 * 行走的精灵

 */

public class Hero extends ShowEntity{

    private int[][] roadline;          //行走的路线

    private int x;                     //当前X坐标

    private int y;                     //当前Y坐标

    private int aimX;               //目标点X

    private int aimY;               //目标点Y

    private int width;                 //宽度

    private int height;                //高度

    private int speed;                 //速度

    private int curGrid = 0;        //行走到的当前格子

   

    public Hero(int[][] riverRoadLine){

       System.out.println("初始化精灵构造方法");

       this.roadline = riverRoadLine;

      

       x = roadline[curGrid][1] * Grid.GRID_WIDTH + (Grid.GRID_WIDTH >> 1) - (width >> 1);

       y = roadline[curGrid][0] * Grid.GRID_HEIGHT + (Grid.GRID_HEIGHT >> 1) - (height >> 1);

       ++curGrid;

       aimX = roadline[curGrid][1] * Grid.GRID_WIDTH + (Grid.GRID_WIDTH >> 1);

       aimY = roadline[curGrid][0] * Grid.GRID_HEIGHT + (Grid.GRID_HEIGHT >> 1);

       width = 20;

       height = 20;

       speed = 4;

    }

   

    @Override

    protected void draw(Graphics g) {

       System.out.println("绘制精灵");

       g.setColor(Color.BLUE);

       g.fillOval(x, y, width, height);

       move();

    }

 

    /**

     * 精灵行走

     */

    public void move(){

       if(curGrid >= roadline.length){

           System.out.println("精灵到达了目的地");

           return;

       }else{

           System.out.println("精灵的行走");

       }

       double spaceX = aimX - x;

       double spaceY = aimY - y;

       double angle = Math.atan2(spaceY, spaceX);

       double fx = Math.cos(angle) * speed;

       double fy = Math.sin(angle) * speed;

       if((aimX - x) * (aimX - x) + (aimY - y) * (aimY - y) < speed * speed){

           //取下一个目标点

           ++curGrid;

           aimX = roadline[curGrid][1] * Grid.GRID_WIDTH + (Grid.GRID_WIDTH >> 1);

           aimY = roadline[curGrid][0] * Grid.GRID_HEIGHT + (Grid.GRID_HEIGHT >> 1);

       }else{

           x += fx;

           y += fy;

       }

    }

}