我的Java阶段项目1 - 骑士飞行棋[两人对战][随机地图版]

最新推荐文章于 2021-02-24 02:16:23 发布

CodingMouse

最新推荐文章于 2021-02-24 02:16:23 发布

阅读量3.9k

点赞数 1

分类专栏： Java 文章标签： java graph string 游戏 eclipse input

本文链接：https://blog.csdn.net/CodingMouse/article/details/2499557

版权

Java 专栏收录该内容

53 篇文章 0 订阅

订阅专栏

package s1java.xmal1.stochasticmap;

/**
 * S1T037阶段项目1 - 骑士飞行棋[随机地图版]
 * 启动游戏类(StartGame)
 * @author 邓超
 * @version 0.1 2008/5/4
 * 开发/测试环境：JDK 1.6 + Eclipse 3.3.2
 */

public class StartGame {

	/**
	 * 启动游戏
	 * @param args
	 */
	public static void main(String[] args) {
		Game game = new Game();   //创建游戏类
		game.start();             //开始游戏
	}
}

package s1java.xmal1.stochasticmap;

/**
 * S1T037阶段项目1 - 骑士飞行棋[随机地图版]
 * 地图类(Map)
 * @author 邓超
 * @version 0.1 2008/5/4
 * 开发/测试环境：JDK 1.6 + Eclipse 3.3.2
 */


public class Map {
	int[] map = new int[100];                               //对战地图
	int[] luckyTurn = new int[6];                           //幸运轮盘 
	int[] landMine = new int[9];                            //地雷位置
	int[] pause = new int[4];                               //暂停
	int[] timeTunnel = new int[7];                          //时空隧道
	int[] especialLattice = new int[luckyTurn.length +      //保存特殊地图格坐标
	                                landMine.length +
	                                pause.length +
	                                timeTunnel.length];

	/**
	 * 生成随机特殊地图格
	 */
	public void randomLattice() {
		int randomNum;     //保存随机整数
		int i, j;          //迭代变量
		//幸运轮盘
		for (i = 0; i < luckyTurn.length; i++) {
			//生成1~98的随机数
			randomNum = (int)Math.round((Math.random() * (98 - 1)) + 1);
			luckyTurn[i] = randomNum;
			//将随机生成的幸运轮盘坐标保存到特殊地图格坐标数组
			especialLattice[i] = luckyTurn[i];
		}
		//地雷位置
		for (i = 0; i < landMine.length; i++) {
			//生成1~98的随机数
			randomNum = (int)Math.round((Math.random() * (98 - 1)) + 1);
			landMine[i] = randomNum;
			for (j = 0; j < especialLattice.length; j++) {
				if (landMine[i] == especialLattice[j]) {    //若特殊地图格重复
					i--;
					break;
				} else if (especialLattice[j] == 0) {       //如果是空位
					especialLattice[j] = landMine[i];
					break;
				}
			}
		}
		//暂停
		for (i = 0; i < pause.length; i++) {
			//生成1~98的随机数
			randomNum = (int)Math.round((Math.random() * (98 - 1)) + 1);
			pause[i] = randomNum;
			for (j = 0; j < especialLattice.length; j++) {
				if (pause[i] == especialLattice[j]) {       //若特殊地图格重复
					i--;
					break;
				} else if (especialLattice[j] == 0) {       //如果是空位
					especialLattice[j] = pause[i];
					break;
				}
			}
		}
		//时空隧道
		for (i = 0; i < timeTunnel.length; i++) {
			//生成1~98的随机数
			randomNum = (int)Math.round((Math.random() * (98 - 1)) + 1);
			timeTunnel[i] = randomNum;
			for (j = 0; j < especialLattice.length; j++) {
				if (timeTunnel[i] == especialLattice[j]) {  //若特殊地图格重复
					i--;
					break;
				} else if (especialLattice[j] == 0) {       //如果是空位
					especialLattice[j] = timeTunnel[i];
					break;
				}
			}
		}
	}
	/**
     * 生成地图: 
     * 关卡代号为：1：幸运轮盘  2：地雷  3: 暂停  4：时空隧道  0：普通
     */
	public void createMap(){
		//生成随机特殊地图格
		randomLattice();
		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--){  //输出28个(对)空格
    			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, 34, playerPos1, playerPos2);     //显示地图右竖行
    	showLine2(35, 66, playerPos1, playerPos2);     //显示地图第二行
    	System.out.println();                          //换行
    	showLLine(66, 68, playerPos1, playerPos2);     //显示地图左竖行
    	showLine1(69, 100, playerPos1, playerPos2);    //显示地图第三行
    }  
}
 
 
 
 
package s1java.xmal1.stochasticmap;

/**
 * S1T037阶段项目1 - 骑士飞行棋[随机地图版]
 * 游戏类(Game)
 * @author 邓超
 * @version 0.1 2008/5/4
 * 开发/测试环境：JDK 1.6 + Eclipse 3.3.2
 */

import java.util.Scanner;                 //导入Scanner类

public class Game {
    Map 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下一次走或停
    }
      
    /**
     * 设置对战角色
     * @param no 玩家次序 1：玩家1 2：玩家2
     * @param role 角色代号为：1：戴高乐  2：艾森豪威尔  3：麦克阿瑟  4：巴顿  其它选择：匿名玩家
     */
    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;
  	  }
    }
    
    /**
     * 开始游戏
     */
      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);
          String role1;
          do {
        	  System.out.print("请玩家1选择角色:  ");
        	  role1 = input.next();  //玩家1选择角色代号
        	  /*只能选择1~4的角色编号*/
          } while (!role1.equals("1") && !role1.equals("2") && !role1.equals("3") && !role1.equals("4"));
          String role2;
          do{
        	  System.out.print("请玩家2选择角色： ");
        	  role2 = input.next();  //玩家2选择角色代号
        	  /*不允许角色重复，且只能选择1~4的角色编号*/
          } while (role2.equals(role1) || !role2.equals("1") && !role2.equals("2") && !role2.equals("3") && !role2.equals("4"));
          setRole(1, Integer.parseInt(role1));    //设置玩家1代表的角色
          setRole(2, Integer.parseInt(role2));    //设置玩家2代表的角色     
          play();                                 //开始两人对战
      }
      
      /**
       * 两人对战玩法
       */
      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 + 1));
                System.out.println("对方当前位置："+ (playerPos2 + 1));
                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 + 1));
            	  System.out.println("对方当前位置："+ (playerPos1 + 1));
            	  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);
    	  input.next();
    	  //产生一个随机数(1~6)作为此玩家掷的骰子数目
    	  step = (int)(Math.random()*10) % 6 + 1;
    	  //返回掷的骰子数
    	  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:                                   //幸运轮盘
    		  char choice;                          //接收玩家选择
    		  do {
    		  System.out.println("/n◆◇◆◇◆欢迎进入幸运轮盘◆◇◆◇◆");
        	  System.out.println("   请选择一种运气：");
        	  System.out.println("   1. 交换位置  2. 轰炸");
        	  System.out.println("=============================/n");
        	  choice  = input.next().charAt(0);
    		  } while (choice != '1' && choice != '2');
        	  int temp;                             //交换时的临时变量
        	  switch(choice){
        	  case '1':                             //交换位置
        		  if(no == 1){                      //position与playerPos2数值互换
        			  temp = position;
        			  position = playerPos2;
        			  playerPos2 = temp; 
        		  }else if(no == 2){                //position与playerPos1数值互换
        			  temp = position;
        			  position = playerPos1;
        			  playerPos1 = temp;
        		  }
        		  break;
        	  case '2':                             //轰炸
        		  //计算玩家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] + "将军! 您获胜了！");
    	  }
      }
}