关于共享盘（文件夹）

package serviceimpl;

import dao.GameNode;
import dao.GameRule;

import java.util.ArrayList;
import java.util.ListIterator;
import java.util.Random;

/**
* 方法实现类
*/
public class GamePlayService {

private static final int TOTAL_NODES = 20;
private static final char[] NODE_TYPES = "AABACADAAAEAAAAEBACA".toCharArray(); // 示例节点分布
private static final Random RANDOM = new Random();

private static final int NUMBER_ONE=1;
/**
* 主方法,游戏开始
*
*/
public void play()
{
ArrayList<GameNode> list=new ArrayList<GameNode>();
GameNode jGameNode=new GameNode();
jGameNode.setNodeName("甲");
jGameNode.setPositions(NUMBER_ONE);
list.add(jGameNode);
GameNode yGameNode=new GameNode();
yGameNode.setNodeName("乙");
yGameNode.setPositions(NUMBER_ONE);
list.add(yGameNode);
GameNode bGameNode=new GameNode();
bGameNode.setNodeName("丙");
bGameNode.setPositions(NUMBER_ONE);
list.add(bGameNode);

//记录第一条获胜选手
String winner = "";

//投掷结果:
System.out.println("投掷和行走结果:");
System.out.println("甲在节点1,乙在节点1,丙在节点1,投掷顺序(甲,乙,丙)");
//记录循环次数
int times = 1;
while (true) {
if (!(list.get(0).getPositions() >= TOTAL_NODES && list.get(1).getPositions() >= TOTAL_NODES && list.get(2).getPositions() >= TOTAL_NODES))
{
System.out.println(" 第" + times + "轮:");
}

times++;
for (GameNode gameNode:list) {
String player = gameNode.getNodeName();
int position = gameNode.getPositions();
//判断甲\乙丙是否达到终点
if (list.get(0).getPositions() >= TOTAL_NODES && list.get(1).getPositions() >= TOTAL_NODES && list.get(2).getPositions() >= TOTAL_NODES) {
//说明都到达了终点
System.out.println(" 第" + times + "轮:");
if(gameNode.getNodeName().equals("甲"))
{
System.out.println(" 甲到达终点！");
System.out.println(" 乙到达终点！");
System.out.println(" 丙到达终点！");
}
else if(gameNode.getNodeName().equals("乙"))
{
System.out.println(" 乙到达终点！");
System.out.println(" 丙到达终点！");
}
else
{
System.out.println(" 丙到达终点！");
}
System.out.println(" 获胜选手:" + winner);
return; // 结束游戏
}
if (position >= TOTAL_NODES) {
if("".equals(winner)){
winner = player;
}
System.out.println(player + " 到达终点！");
continue;
}
//选择最大的投掷点数
int selectMaxNum = selectRollDice();
//根据最大投掷点数,进行投掷
int roll = rollDice(selectMaxNum);
// System.out.println(player+"投掷结果"+roll);
position += roll;
int upTimePosition=gameNode.getPositions();
// 检查是否到达终点
if (position >= TOTAL_NODES) {
mesView(gameNode,upTimePosition,position,selectMaxNum,roll,new GameRule());
if("".equals(winner)){
winner = player;
}
} else {
// 处理节点规则
GameRule rule= handleNodeType(position, player, selectMaxNum);
if("C".equals(rule.getType()))
{
gameNode.setPositions(position+rule.getSecondRollNum());
}
else
{
gameNode.setPositions(rule.getPositionNum());
}
// System.out.println("投掷的类型"+rule.getType());
mesView(gameNode,upTimePosition,position,selectMaxNum,roll,rule);
}
}
}

}

/**
* 消息显示处理
*
*/
private void mesView(GameNode gameNode,int upTimePosition,int operatedPosition,int selectMaxNum,int roll,GameRule gameRule)
{
//投掷无效的处理
if (gameNode.getPositions() == upTimePosition) {
System.out.println(gameNode.getNodeName() + ":投掷选择 " + selectMaxNum + " 结果 " + roll + "，投掷无效一次");
} else if ("B".equals(gameRule.getType()) || "D".equals(gameRule.getType())) {
//投掷回退处理
System.out.println(gameNode.getNodeName() + ":投掷选择 " + selectMaxNum + ", 结果 " + roll + "，现在位于节点 " + gameNode.getPositions() + "将" + gameNode.getNodeName() + "踢回至节点" + gameNode.getPositions());
} else {
//前进的处理
if (gameNode.getPositions() >= 20) {
if("C".equals(gameRule.getType()))
{
System.out.println(gameNode.getNodeName() + ":投掷选择 " + selectMaxNum + " 结果 " + gameRule.getSecondRollNum() + "，现在位于节点 " + gameNode.getPositions() + ",到达终点");
}
else
{
System.out.println(gameNode.getNodeName() + ":投掷选择 " + selectMaxNum + " 结果 " + roll + "，现在位于节点 " + gameNode.getPositions() + ",到达终点");
}

} else {
if("C".equals(gameRule.getType()))
{
System.out.println(gameNode.getNodeName() + ":投掷选择 " + selectMaxNum + " 结果 " + gameRule.getSecondRollNum() + "，现在位于节点 " + gameNode.getPositions());
}
else
{
System.out.println(gameNode.getNodeName() + ":投掷选择 " + selectMaxNum + " 结果 " + roll + "，现在位于节点 " + gameNode.getPositions());
}

}
}
}
/**
* 使用选择最大数进行投掷的点数
*
* @param selectNum 选择的最大值范围
* @return
*/
private static int rollDice(int selectNum) {
return RANDOM.nextInt(selectNum) + 1; // 产生1到6之间的随机数
}

/**
* 获取选择的最大数
*
* @return
*/
private static int selectRollDice() {
return RANDOM.nextInt(6) + 1; // 产生1到6之间的随机数
}

/**
* 投掷的节点逻辑处理
*
* @param position 位置点数
* @param player 选手
* @param selectMaxNum 选择的最大点数
* @return
*/
private GameRule handleNodeType(int position, String player, int selectMaxNum) {
char nodeType = NODE_TYPES[position - 1];
GameRule rule=new GameRule();
switch (nodeType) {
case 'A':
// 普通节点，无特殊操作
// System.out.println(player+"普通节点");
rule.setPositionNum(position);
rule.setType("A");
return rule;
case 'B':
// 回退一步
// System.out.println(player+"回退一步");
rule.setPositionNum(Math.max(1, position - 1));
rule.setType("B");
return rule;

case 'C':
// 投掷一次无效一次，需要再次投掷
// System.out.println(player+"投掷一次无效一次，需要再次投掷");
int secondRoll = rollDice(selectMaxNum);
// System.out.println("投掷无效,重新投了一次"+secondRoll);
rule.setSecondRollNum(secondRoll);
rule.setPositionNum(position + secondRoll);
rule.setType("C");
return rule;
case 'D':
// System.out.println(player+"回到出发节点1");
// 回到出发节点1
rule.setPositionNum(1);
rule.setType("D");
return rule;
case 'E':
// 回到上一个E节点，如果没有则视为A节点处理
// System.out.println(player+"回到出发节点1");
for (int i = position - 2; i >= 0; i--) {
if (NODE_TYPES[i] == 'E') {
rule.setPositionNum(i + 1);
rule.setType("E");
return rule;

}
}
// 如果没有找到上一个E节点，则视为A节点处理（即无特殊操作）
break;
default:
throw new IllegalArgumentException("Unknown node type: " + nodeType);
}
return rule;
}
}