7*7矩阵 WILD(131)素材参与连线时，消除时在连线宫格区域内按配置生成1~5个1X\2X翻倍图标

Question

需求: 7*7矩阵，严格看一下以下代码,我的需求是
     1.假设wildList=[5_3,0_2,1_2,1_4,5_3] 当然wildList有很值的可能，这只是一种假设，注意:矩阵 行列下标存储的,然后也是可以出现重复的 
     2. List<SlotGameLineData> list 有好几条数据, 假设list里面的di每条数据里面都有一个getMaterialPos，然后存储的值是getMaterialPos=[0_1,0_2,1_2,1_4,1_3] 当然getMaterialPos有很值的可能，这只是一种假设，注意:矩阵 行列下标存储的 
     3.当WILD(131)素材参与连线时，消除时(list存储的就是消除区域 只是有的是没有WILD参与，所以要参与的才给翻倍图标，没参与的不管让她继续放在list里面)在连线宫格区域内按配置生成1~5个1X\2X翻倍图标，
     4.当所在宫格中已经存在翻倍图标时，再次消除命中所在宫格时，当前宫格内翻倍图标值*2
     5. 假设list有3条数据 四条分别是getMaterialPos=[0_1,0_2,1_2,1_4,1_3]，getMaterialPos=[1_1,1_2,2_2,2_4,2_3]，getMaterialPos=[3_1,3_2,4_2,5_4,5_3]，getMaterialPos=[2_1,0_2,1_2,4_4,5_3]
     6.然后我就是会拿到矩阵是131的位置，假设如果矩阵131的位置在5_3,并且list 里面也有，就把万能位置放进wildList，然后去list 里面每一条找getMaterialPos有没有5_3，我发现有两条都有，
     就拿到这两条数据getMaterialPos=[3_1,3_2,4_2,5_4,5_3]，getMaterialPos=[2_1,0_2,1_2,4_4,5_3]，然后拿到的数据里面每条随机取1-5个位置给翻倍值,getRanPositions是我随机的方法，一条里面取出来的几个位置给赋值1或者2，int multiplying = random.nextInt(100) < 70 ? 1 : 2;
                                matrixFree[r][c] = multiplying;就是需要注意的是给赋值过倍率的位置，下一次又在list 里面出现过，就以前的翻倍值 *2，这是我写的matrixFree[r][c] *= 2;就是不知道对不对，当所在宫格中已经存在翻倍图标时，再次消除命中所在宫格时，当前宫格内翻倍图标值*2 
    7.能理解我的需求吗,我现在就是感觉我代码不对，翻倍率不对，反正就是getMaterialPos那条数据里面有万能就要随机给翻倍图标，没有出现万能就不给翻倍图标,随机给的翻倍图标下一次再次中奖就要*2 再次中奖那条也还是要随机取一两个 只是之前的翻倍，
public void matrixNEWAIJI(int[][] resultMatrix, boolean noBingo) {
        for (int j = 0; j < col; j++) {
            for (int i = 0; i < row; i++) {
                if(matrix[i][j] == 0){
                    //素材结果
                    int materia = 0;
                    int num = random.nextInt(70);
                    
                    if(num>=0 && num<=9){
                        materia = GameMaterialConstant.GAME_NORMAL_MATERIAL_101;
                    }else if(num>=10 && num<=19){
                        materia = GameMaterialConstant.GAME_NORMAL_MATERIAL_103;
                    }else if(num>=20 && num<=29){
                        materia = GameMaterialConstant.GAME_NORMAL_MATERIAL_107;
                    }else if(num>=30 && num<=39){
                        materia = GameMaterialConstant.GAME_NORMAL_MATERIAL_109;
                    }else if(num>=40 && num<=49){
                        materia = GameMaterialConstant.GAME_NORMAL_MATERIAL_113;
                    }else if(num>=50 && num<=59){
                        materia = GameMaterialConstant.GAME_NORMAL_MATERIAL_127;
                    }else if(num>=60 && num<=69){
                        materia = GameMaterialConstant.GAME_NORMAL_MATERIAL_131;
                    }
                    matrix[i][j] = materia;
                    if(noBingo && getAdjacentMaterialList(matrix).size()>0){
                        matrix[i][j] = 0;
                        i -= 1;
                        continue;
                    }
                }
                }
                }
        List<SlotGameLineData> list = getAdjacentMaterialList(matrix);
        List<String> wildList = new ArrayList<String>(new HashSet<String>(getWildList())); // 使用 Set 去除重复元素
        wildPositions(list, matrix, wildList);
        logger.info("wildList`````````````" + wildList);
        if (!list.isEmpty()) {
            for (String wildItem : wildList) {
                boolean exist = false; // 标记该万能wildItem中是否出现过
                for (SlotGameLineData data : list) {
                    String[] posArr = data.getMaterialPos().split(",");
                    if (Arrays.asList(posArr).contains(wildItem)) {
                        exist = true;
                        List<String> ranPositions = new ArrayList<String>(Arrays.asList(getRanPositions(posArr)));
                        for (String pos : ranPositions) {
                            int r = Integer.parseInt(pos.split("_")[0]);
                            int c = Integer.parseInt(pos.split("_")[1]);

                            if (r < 0 || r >= matrix.length || c < 0 || c >= matrix[0].length) {
                                continue; // 跳过超出矩阵范围的位置
                            }
                            matrix[r][c] = 0;
                            if ((gameTypeId == GameConstant.GAME_PLAY_TYPE_NEWAIJI && matrixFree[r][c] >= 128) || matrixFree[r][c] >= 1024) {
                                continue;
                            }
                            if (matrixFree[r][c] > 0) {
                                matrixFree[r][c] *= 2;
                            } else {
                                int multiplying = random.nextInt(100) < 70 ? 1 : 2;
                                matrixFree[r][c] = multiplying;
                            }
                            String newBonus = r + "_" + (c + matrixsBonus.size() * col) + "_" + matrixFree[r][c];
                            bonusList.add(newBonus);
                        }
                    }
                }
                if (!exist) {
                    continue;
                }
               // matrixNEWAIJI(matrix, noBingo);
            }
            matrixNEWAIJI(matrix, noBingo);
        }
        
    }
    
    // 根据概率随机选择要获取的位置数量
    private String[] getRanPositions(String[] posArr) {
          Random random = new Random();
            List<String> positions = Arrays.asList(posArr);
            int num;
            int rand = random.nextInt(100);
            if (rand < 45) {
                num = 1;
            } else if (rand < 83) {
                num = 2;
            } else if (rand < 95) {
                num = 3;
            } else if (rand < 99) {
                num = 4;
            } else {
                num = 5;
            }
       
        Collections.shuffle(positions); // 打乱
        return positions.subList(0, Math.min(num, positions.size())).toArray(new String[0]);
    }
    
    // 矩阵出现过的131并且getMaterialPos有就存进去wildList
    private void wildPositions(List<SlotGameLineData> list, int[][] matrix, List<String> wildList) {
        for (int i = 0; i < 7; i++) {
            for (int j = 0; j < 7; j++) {
                if (matrix[i][j] == 131) {
                    String pos = i + "_" + j;
                    for (SlotGameLineData data : list) {
                        String[] positions = data.getMaterialPos().split(",");
                        for (String position : positions) {
                            if (position.equals(pos)) {
                                wildList.add(pos);
                                break;
                            }
                        }
                    }
                }
            }
        }
    }

Answer 1

以下内容由CHATGPT及阿里嘎多学长共同生成、有用望采纳：

---

根据你的需求，我将提供一些代码逻辑上的建议和可能的实现方法。请注意，由于我无法直接运行代码，以下建议需要你自己在实际环境中进行测试和调整。

代码逻辑建议

1. 初始化翻倍图标矩阵 (matrixFree)：确保有一个矩阵来跟踪每个宫格的翻倍图标状态。

2. 处理WILD素材：当检测到WILD素材参与连线时，需要在对应的宫格位置生成翻倍图标。

3. 随机生成翻倍图标：对于每个包含WILD素材的连线，随机选择1到5个宫格位置生成翻倍图标。

4. 翻倍图标翻倍：当一个宫格已经被赋予翻倍图标，并且再次被选中时，需要将该宫格的翻倍图标值翻倍。

5. 更新翻倍图标矩阵：在每次消除操作后，更新matrixFree矩阵以反映翻倍图标的最新状态。

代码实现示例

以下是一个简化的代码示例，展示了如何根据你的描述实现翻倍图标的生成和更新逻辑：

public void processWildAndDoubleIcons(int[][] matrix, List<SlotGameLineData> list) {
    // 假设wildList已经初始化并填充了WILD素材的位置
    List<String> wildList = ...;

    // 初始化翻倍图标矩阵，如果尚未初始化
    int[][] matrixFree = new int[7][7];
    for (int i = 0; i < 7; i++) {
        for (int j = 0; j < 7; j++) {
            matrixFree[i][j] = 0; // 初始化为0，表示没有翻倍图标
        }
    }

    // 遍历每条连线数据
    for (SlotGameLineData data : list) {
        // 检查该连线是否包含WILD素材
        if (wildList.contains(data.getMaterialPos())) {
            // 随机选择1到5个宫格位置生成翻倍图标
            List<String> positions = Arrays.asList(data.getMaterialPos().split(","));
            int numIcons = 1 + (int)(Math.random() * 5);
            List<String> selectedPositions = new ArrayList<>(positions.subList(0, numIcons));

            // 更新翻倍图标矩阵
            for (String pos : selectedPositions) {
                int r = Integer.parseInt(pos.split("_")[0]);
                int c = Integer.parseInt(pos.split("_")[1]);
                if (matrixFree[r][c] == 0) {
                    // 如果宫格内没有翻倍图标，则生成新的翻倍图标
                    matrixFree[r][c] = (int)(Math.random() < 0.7 ? 1 : 2);
                } else {
                    // 如果宫格内已经有翻倍图标，则翻倍
                    matrixFree[r][c] *= 2;
                }
            }
        }
    }
}

注意事项

• 确保wildList正确地包含了所有WILD素材的位置。
• 在实际代码中，你可能需要根据实际的游戏逻辑调整随机数生成和条件判断。
• 代码中的...需要你根据实际情况填充具体的值或逻辑。

参考资料

由于这是一个具体的编程问题，可能没有现成的参考资料。但是，你可以查找关于Java编程、集合操作、随机数生成等方面的资料来帮助你理解和实现上述逻辑。

希望这些建议能帮助你解决问题。如果有任何具体的问题或需要进一步的帮助，请随时提问。