我这个方法是往7行6列矩阵里面塞素材，每次有某个素材达到8个的时候就把矩阵清0 继续再次调用这个方法，但是现实我想自己控制

Question

我这个方法是往7行6列矩阵里面塞素材，每次有某个素材达到8个的时候就把矩阵清0 继续再次调用这个方法，但是现实我想自己控制，就是我给你素材要几个你就往中间几行放几个 然后还会要求你同一个方法调用几次，假设方法参数有一个List<ModuleGameOdds> materials，里面装的是要求中奖 139素材id，数量9个，第二条131素材id，数量10个，注意中奖的还是在中间5行出现，比如139 要9个，那中奖5行必须要有9个，然后会消掉，再去往中间放131，但是第一行会落下来，可能会影响格子数量 所以在第一行就需要安排后面一次的素材数量了,而且这还是消完只调用一次，这只是假设，因为还有可能出现调用很多次的情况，可以怎么实现 中文解释 中文详细注释    public void matrixMAHJONG(int[][] resultMatrix,List<ModuleGameOdds> materials, int freeNum) {
        if (resultMatrix != null) {
            matrix = fallMatrixs();
            dataMap.clear();
            //下落之后更新一下   dataMap的值
            for (int i = 1; i < matrix.length - 1; i++) {
                for (int j = 0; j < matrix[i].length; j++) {
                    if (matrix[i][j] != 0) {
                        int count = matrix[i][j];
                        if (dataMap.containsKey(count)) {
                            dataMap.put(count, dataMap.get(count) + 1); // 更新素材计数
                        } else {
                            dataMap.put(count, 1); // 添加新素材
                        }
                    }
                }
            }
            
        } else {
            matrixEmptyNum = (row-1) * col;
            logger.info("总格子······"+matrixEmptyNum);
            matrix = new int[row][col];
        }
        
        int aa=1;
        if (aa==1 && isBoubleFlag()==false) {
            materials.clear();
            ModuleGameOdds mGameOdds = new ModuleGameOdds(); 
            mGameOdds.setId(9);
            mGameOdds.setMaterialId(139);
            materials.add(mGameOdds);
            
             ModuleGameOdds mGameOdds2 = new ModuleGameOdds(); 
            mGameOdds2.setId(9); 
            mGameOdds2.setMaterialId(139);  
            materials.add(mGameOdds2);
            
            ModuleGameOdds mGameOdds3 = new ModuleGameOdds(); 
            mGameOdds3.setId(9); 
            mGameOdds3.setMaterialId(127);  
            materials.add(mGameOdds3);
        
            ModuleGameOdds mGameOdds4 = new ModuleGameOdds(); 
            mGameOdds4.setId(9); 
            mGameOdds4.setMaterialId(101);  
            materials.add(mGameOdds4);
            
            setBoubleFlag(true);
            for (int i = 0; i < materials.size(); i++) {
                logger.info("--------material="+materials.get(i).getMaterialId()+","+materials.get(i).getId());
            }
        }
        aa=0;
    
        
        int materialsNum = 0;//上次的数量
        Map<Integer, Integer> materialMap = new HashMap<Integer, Integer>();
        List<SlotResultParam> paramList = new ArrayList<SlotResultParam>();
        if (materials.size()>0) {
                if (materials.size() > 0) {//至少中一个素材
                    ModuleGameOdds materialOdd = materials.remove(0);
                    int material = materialOdd.getMaterialId();
                    int num = materialOdd.getId()- (dataMap.get(material) == null ? 0 : dataMap.get(material));//还差几个
                    int hasNum = dataMap.get(material) == null ? 0 : dataMap.get(material);// 矩阵现有素材数量
                    materialsNum=materialOdd.getId();
                    materialMap.put(material, num);
                    allWildCol.clear();
                    allWildCol.add(material);//临时存储一下中奖的素材id;
                    matrixEmptyNum -= num;
                    SlotResultParam materialParam = new SlotResultParam(material, num,new int[] { 0, 1, 2, 3, 4, 5 }, row);
                    paramList.add(materialParam);//添加要中奖的素材
                    dataMap.put(material, (hasNum+num));
//                    dataMap.put(material, (num+(materialOdd.getId()-num)));
                    logger.info("需要的素材数量~~~~"+num);
                    logger.info("总格子······"+matrixEmptyNum);
            }
                
        }
        logger.info("allWildCol~~~~"+allWildCol);
        
        for (int i = 0; i < materials.size(); i++) {
            if (matrixEmptyNum <= 0 || materialMap.size() >= 6) {
                break;
            }
            ModuleGameOdds moduleGameOdds = materials.get(i);
            int material = moduleGameOdds.getMaterialId();
            logger.info("需要的素材ID~~~"+material + "     素材数量"+moduleGameOdds.getId());
            int hasNum = dataMap.get(material) == null ? 0 : dataMap.get(material);// 矩阵现有素材数量
            logger.info("矩阵有的数量~~~~"+hasNum+ "我要的```"+moduleGameOdds.getId() + "````上一个的素材数量materialsNum=="+materialsNum);
            
            int num = 0;// 需要素材数量
            if (!materialMap.containsKey(moduleGameOdds.getMaterialId())) {
                if (matrixEmptyNum > 0 && hasNum < 7) {
                    int value= materialsNum-6;//代表中间可以放的数量
                    if (moduleGameOdds.getId()>value && hasNum+value<moduleGameOdds.getId()) {// 如果要的数量比中间可以放的位置多    && 矩阵里面现在存在的和   中间 能放下的都比我要的数量少的情况
                        if (matrixEmptyNum + hasNum > 7) {
                            num=moduleGameOdds.getId()-value;//num代表我要在第一排或者中间提前需要放置的数量
                        }
                    }else {
                        int rand = matrixEmptyNum;
                        if (matrixEmptyNum + hasNum > 7) {
                            rand = 7 - hasNum;
                        }
                            int range = Math.min(7 - hasNum, rand); 
                            num = random.nextInt(range) + 1;
                        }
                }
                    SlotResultParam materialParam = new SlotResultParam(material, num,new int[] { 0, 1, 2, 3, 4, 5 }, row);
                    SlotResultParam freeNums = new SlotResultParam(material, freeNum,new int[] { 0, 1, 2, 3, 4, 5 }, row);
                     paramList.add(materialParam);
                     paramList.add(freeNums);
                     dataMap.put(material,num+hasNum);
                if (num > 0) {
                    materialMap.put(material, num);
                    matrixEmptyNum -= num;
                    logger.info("总格子······"+matrixEmptyNum);
                }
                logger.info("需要的素材数量~~~~"+num);
            }else {
                if (matrixEmptyNum + hasNum > 7 ) {
                    num=moduleGameOdds.getId()-(materialsNum-6);
                    SlotResultParam materialParam = new SlotResultParam(material, num,new int[] { 0, 1, 2, 3, 4, 5 }, row);
                    materialParam.setFlag(true);
                    paramList.add(materialParam);
                    dataMap.put(material,hasNum);
                    logger.info("需要的素材数量~~~~"+num);
                }
                if (num > 0) {
                    materialMap.put(material, num);
                    matrixEmptyNum -= num;
                    logger.info("总格子······"+matrixEmptyNum);
                }
            }
            
        }
    
        matrix = createSlotResult(paramList, GameConstant.GAME_PLAY_TYPE_TMCF);
        
        // 普通素材
        List<Integer> list = new ArrayList<Integer>();
        list.add(GameMaterialConstant.GAME_NORMAL_MATERIAL_101);
        list.add(GameMaterialConstant.GAME_NORMAL_MATERIAL_103);
        list.add(GameMaterialConstant.GAME_NORMAL_MATERIAL_107);
        list.add(GameMaterialConstant.GAME_NORMAL_MATERIAL_109);
        list.add(GameMaterialConstant.GAME_NORMAL_MATERIAL_113);
        list.add(GameMaterialConstant.GAME_NORMAL_MATERIAL_127);
        list.add(GameMaterialConstant.GAME_NORMAL_MATERIAL_131);
        list.add(GameMaterialConstant.GAME_NORMAL_MATERIAL_137);
        list.add(GameMaterialConstant.GAME_NORMAL_MATERIAL_139);
        for (int j = 0; j < col; j++) { 
            for (int i = 0; i < row ; i++) {
                if (matrix[i][j] == 0) {
                    int materia = list.get(random.nextInt(list.size()));
                    if (!materialMap.containsKey(materia)) { // 不放materialMap里面要的素材 放不参与中奖的素材
                            if (dataMap.get(materia) != null) {
                                if (dataMap.get(materia) < 7) {
                                    matrix[i][j] = materia;
                                    if ((i != 0 && i != row - 1)) {//第一行和最后一行数量不计
                                    dataMap.put(materia, dataMap.get(materia) + 1);
                                     }
                                } else {
                                    i--;
                                }
                            } else {
                                matrix[i][j] = materia;
                                if ((i != 0 && i != row - 1)) {
                                  dataMap.put(materia, 1);
                                }
                            }
                    } else {
                        i -= 1;
                    }
                }
            }
        }
    
        matrixEmptyNum = 0;
        for (int i = 0; i < matrix.length; i++) {
            List<Integer> cardList = new ArrayList<Integer>();
            for (int j = 0; j < matrix[i].length; j++) {
                cardList.add(matrix[i][j]);
                 System.out.print(matrix[i][j]+"\t");
            }
            matrixList.add(cardList);
             System.out.println();
        }
        
        matrixs.add(fuzhiMatrix(matrix));
        logger.info("dataMap=" + dataMap);

        Map<Integer, Integer> tempMap = new HashMap<Integer, Integer>();
        for (Integer id : dataMap.keySet()) {
            if (dataMap.get(id) > 7) {
                matrixEmptyNum += dataMap.get(id);
                tempMap.put(id, dataMap.get(id));
                // 删除矩阵里这个素材
                removeMaterial(matrix, id);//第一行和最后一行有中奖的那个不删
                dataMap.put(id, 0);
            }
        }
        if (tempMap.size() > 0) {
            materialNumMap.add(tempMap);
            logger.info("materialNumMap=" + materialNumMap);
            matrixMAHJONG(matrix, materials, freeNum);
        }
    }
createSlotResult方法是往矩阵中间放但是数量可能把控的不对，导致没有格子

Answer 1

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

---

根据您提供的代码和需求，我理解您想要实现一个可以控制素材放置的算法，并且在满足特定条件下重新调用该方法。以下是对您现有代码的一些建议和修改，以及一个简化的示例实现。

代码分析和建议

1. 数据结构优化：

   • 您的代码中使用 Map<Integer, Integer> 来跟踪素材的数量，这可能不足以处理复杂的放置逻辑。考虑使用 Map<Integer, List<Integer>> 来跟踪每种素材的放置位置。

2. 素材放置逻辑：

   • 您的 createSlotResult 方法需要根据 materials 列表中的要求来放置素材，并且确保放置的数量正确。

3. 素材溢出处理：

   • 当素材数量达到8个时，您需要清零矩阵。这可以通过遍历 dataMap 来实现，如果某个素材的数量超过7，就将其从 matrix 中移除，并更新 dataMap。

4. 代码重构：

   • 您的代码中存在一些冗余和可能的逻辑错误。例如，materials.clear() 应该在循环之前调用，以避免在循环中删除正在处理的元素。

5. 增加注释：

   • 代码中缺少注释，添加详细的注释可以帮助理解代码的逻辑。

简化示例实现

以下是一个简化的示例，展示如何根据 materials 列表中的要求控制素材的放置：

public void placeMaterials(int[][] matrix, List<ModuleGameOdds> materials) {
    // 清空矩阵
    for (int i = 0; i < matrix.length; i++) {
        for (int j = 0; j < matrix[i].length; j++) {
            matrix[i][j] = 0;
        }
    }

    // 放置素材
    for (ModuleGameOdds material : materials) {
        int materialId = material.getMaterialId();
        int numToPlace = material.getId();
        int placedCount = 0;

        // 尝试在矩阵中间5行放置素材
        for (int i = 1; i < 6 && placedCount < numToPlace; i++) {
            for (int j = 0; j < matrix[i].length && placedCount < numToPlace; j++) {
                if (matrix[i][j] == 0) {
                    matrix[i][j] = materialId;
                    placedCount++;
                }
            }
        }

        // 如果放置的数量不足，可以在这里处理溢出逻辑
        if (placedCount < numToPlace) {
            // 处理溢出逻辑，例如重新调用方法或等待
        }
    }

    // 检查是否有素材数量超过8，如果有则清零矩阵并重新调用方法
    for (int materialId : dataMap.keySet()) {
        if (dataMap.get(materialId) >= 8) {
            // 清零矩阵
            for (int i = 0; i < matrix.length; i++) {
                for (int j = 0; j < matrix[i].length; j++) {
                    matrix[i][j] = 0;
                }
            }
            // 重新调用方法
            placeMaterials(matrix, materials);
            return;
        }
    }
}

请注意，这个示例是一个简化的版本，它没有处理所有可能的情况，例如素材溢出的具体逻辑。您需要根据这个示例调整自己的代码，以确保它能够正确地放置素材并处理各种情况。

结论

实现一个复杂的素材放置算法需要仔细考虑各种边界条件和逻辑流程。上述建议和示例提供了一个起点，但您可能需要根据您的具体需求进一步调整和优化代码。