Question

我创造了一个游戏 - 一种颜色网格，玩家可以向上，向下，向左或向右导航。如果方向说＆＃34;去红场＆＃34;，玩家必须这样做。玩家必须遵循的路径由遵循以下规则的随机路径生成算法确定：

游戏规则：

这是一款帮助人们练习外语的迷宫
播放器被赋予颜色网格，它们沿着下一个给定的颜色遍历随机生成的从左到右的路径（如果随机生成的路径上的下一个颜色是红色，则会提示它们转到红色方块） - 显然后来提示将使用外语
例如，＆＃34; Rojo＆＃34;来了，他们必须去红场
这将是基于时间的...如果你在同一个瓷砖上停留太久，你会受到伤害
如果你踩错了颜色，就会受到伤害
由于迷宫是从左到右生成的（请参阅下面的算法信息），他们可以选择移动到北，东或南节点

逻辑规则：

从左到右，意味着在第0列选择随机行
路径必须从col 0连接到最后一列
路径有风，但它无法往返，意味着它可以循环向上，向下和向右
彼此相邻的节点不能共享相同的颜色
当前节点的北，东，南节点（例如灰色节点）不能共享相同的颜色
在生成随机路径时预先生成颜色提示（下一个要移动的单元格）...在网格创建时将每种颜色分配给一个单元格......随机生成的路径存储顺序/路径那些颜色都在...所以我可以将下一个颜色传递给玩家，让他们继续前进。

路径生成算法信息：Random path generation algorithm

我正在生成随机颜色的网格。当然，这意味着它不能完全随机，因为我需要确保玩家不能有一个以上的邻居颜色可供选择。

此图片描述了：灰色单元格是玩家的起始位置......北方，东方和南方的邻居都拥有相同的颜色......这很糟糕。

enter image description here

在游戏中

enter image description here

网格是彩色图块图像的网格。因此瓷砖＆＃34;颜色＆＃34;生成网格后不应该更改。在网格创建期间，每个新单元格，我创建一个随机索引，并将单元格颜色设置为colorsObject [randomIndex]，以确保分配随机颜色

为了尝试解决这个问题，我尝试存储最后使用的颜色...并且在下一次创建单元格的迭代中，我从colors对象中删除了存储的最后使用的颜色（出于我自己的原因需要一个对象，否则将使用数组），设置随机选择缩短的颜色列表，并使用该颜色。然后将lastUsedColor添加回对象：

    var lastUsedColor = "";
    for (var row = 0; row <= bridgeSegment.settings.rows-1; row++) {
        this.grid[row] = []; 
        for (var col = 0; col <= bridgeSegment.settings.cols-1; col++) {                
            if (lastUsedColor != "") delete this.colors[lastUsedColor];

            var colorIndex = Math.floor(Math.random() * (Object.keys(this.colors).length - 0) + 0);

            var keyName = Object.keys(this.colors)[colorIndex]; 

            image = (this.maze == 1) ? image : keyName;

            if (lastUsedColor != "") this.colors[lastUsedColor] = lastUsedColor;
            lastUsedColor = keyName;

            var myCell = me.pool.pull("mazetile", x, y, {
                name : "mazetile",
                type : "mazetile",
                image : image,
                row : row,
                col : col,
                width: 64,
                height : 64,
                spritewidth : 64
            });
            me.game.world.addChild(myCell);
            this.grids[row][col] = myCell;  
        }

这在逐行的基础上工作（意味着2个相邻的列不会共享相同的颜色），但在下一行中，可能存在具有相同颜色的相邻节点。

我的下一个想法是首先生成所有具有颜色的平铺图像...然后再次迭代以检查相邻颜色...如果有，则换出新图像。但是我希望在生成一组tile时完成这项工作，而不必再进行另一个嵌套for循环。

我已经尝试过roko建议的方法，以及＆＃34;迷宫＆＃34;现在工作正常，但是当玩家移动到桥的下一部分时（我在网格中生成了第二组图块，请参阅此图片，我的意思是：http://i.imgur.com/Hlerxm3.png），没有＆似乎是他附近的颜色：

enter image description here

你可以看到它说＆＃34;黄色＆＃34;，但他周围没有黄色选项。

代码:(省略代码实际循环并生成网格，因为这不是问题）

run : function (maze) {
    this.maze= maze;
    this.list = [];
    this.containerOfGrids = [];
    this.myDirectionsText = new game.HUD.ScreenText(630, 10, 10, 10, {font: "32x32_font", text: "1"})

    game.data.gameHUD.addChild(this.myDirectionsText);          
    for (var i = 0; i <= game.data.bridgeSegments.length-1; i++) {
        this.containerOfGrids[i] = [];
        this.createGrid(game.data.bridgeSegments[i], i);                
    }

    //call to set initial color cell
    this.firstCell();

},

最初调用以选择第一个单元格..如果它是顶部桥接段（桥形1），我需要从第一列中的随机行开始...如果它是其他网格随着路径的缩小，我需要选择一个随机列......

firstCell : function () {
    //choose intitial random starting cell 
    if (game.data.bridgeSegments[this.bridgeIndex].settings.realname == "bridge_shape_1") {
        var row = Math.floor(Math.random() * (this.containerOfGrids[this.bridgeIndex].length - 0) + 0);
        var col = 0;    
        this.gridLen = this.containerOfGrids[this.bridgeIndex][row].length;
    }
    else {
        var row = 0;
        var col = Math.floor(Math.random() * (this.containerOfGrids[this.bridgeIndex][row].length - 0) + 0);
        this.gridLen = this.containerOfGrids[this.bridgeIndex].length;
    }
    this.containerOfGrids[this.bridgeIndex][row][col].firstCell = true;

    this.currColor = this.containerOfGrids[this.bridgeIndex][row][col].color;
    this.containerOfGrids[this.bridgeIndex][row][col].renderable.alpha = 1;
    this.myDirectionsText.settings.text = this.containerOfGrids[this.bridgeIndex][row][col].color;

},

//passing in collided cell, cell row and col from the Tile Class
nextCell : function (cell, row, col) {
    if (cell.col < this.gridLen) {  
        this.checkValidCells(row, col);
        this.checkValidMove(cell, this.currColor);

        var randomNumber = Math.floor(Math.random() * (this.list.length));          
        this.currColor = (this.list.length > 0) ? this.list[randomNumber].color : "RED";
        this.myDirectionsText.settings.text = this.currColor; 
    }

},

checkValidMove : function (cell, color) {
    if (cell.color == color) {
        cell.renderable.image = (game.data.bridgeSegments[this.bridgeIndex].settings.view == "topdown") ? me.loader.getImage("MyFlatTile3") :  me.loader.getImage("Tile128Green");          
    }
    else {
        game.data.health -=10;
        cell.renderable.image = (game.data.bridgeSegments[this.bridgeIndex].settings.view == "topdown") ? me.loader.getImage("MyFlatTile3") :  me.loader.getImage("Tile128Red");
    }
    cell.renderable.alpha = 1;  
},

checkValidCells : function (row, col) {
    this.list = [];


    if (row - 1 >= 0) {
        if (!this.containerOfGrids[this.bridgeIndex][row-1][col].explored) {
            this.list.push(this.containerOfGrids[this.bridgeIndex][row-1][col]);
        }
    }

    if (col - 1 >= 0) {
        if (!this.containerOfGrids[this.bridgeIndex][row][col-1].explored) {
            this.list.push(this.containerOfGrids[this.bridgeIndex][row][col-1]);
        }
    }       

    if (col + 1 < this.containerOfGrids[this.bridgeIndex][row].length && this.containerOfGrids[this.bridgeIndex][row][col + 1] != "undefined")  {
        if (!this.containerOfGrids[this.bridgeIndex][row][col+1].explored) {
            this.list.push(this.containerOfGrids[this.bridgeIndex][row][col+1]);
        }

    }
    if (row + 1 < this.containerOfGrids[this.bridgeIndex].length && this.containerOfGrids[this.bridgeIndex][row+1][col] != "undefined") {
        if (!this.containerOfGrids[this.bridgeIndex][row+1][col].explored) {
            this.list.push(this.containerOfGrids[this.bridgeIndex][row+1][col]);
        }
    }

}

在我的tile类中，我在与当前单元格碰撞时启动下一个单元格：

        if (!this.explored) {
            nextCell(this, this.row, this.col);
            this.explored=true;
        }

Answer 1

这有用吗？我不确定我是否完全理解这个问题，但我认为这是正确的。我正在创建一个名为grid的数组，并用随机颜色填充它，每次检查它与附近的颜色相同。

~~编辑：不，这还不行。我会尝试解决它。~~ 好的，我想我修好了。

    grid = [];
for(var i=0;i<=totalRows;row++)
{
    grid[i]=[]
    for(var j=0;j<=totalCols;j++)
    {
        do
        {
            var colorIndex = Math.floor(Math.random() * (Object.keys(this.colors).length - 0) + 0);
            var keyName = Object.keys(this.colors)[colorIndex]; 
            grid[i][j]=keyName;
            var nearSameColor=false;
            for(var k=i-2;k<=i+2;k++)
            {
                if(k<0||k>totalRows)
                    continue;
                for(var l=j-2;l<=l+2;l++)
                {
                    if(l<0||l>totalCols||(k==i&&l==j))
                        continue;
                    nearSameColor=nearSameColor||grid[i+k][j+l]==grid[i][i];
                }
            }
        }while(nearSameColor)
    }
}
for (var row = 0; row <= totalRows; row++) {
    this.containerOfGrids[i][row] = [];
    for (var col = 0; col <= totalCols; col++) {
        image = grid[row][col];

        //other code

Answer 2

如果我理解你的话，你不仅要关心不要在自身旁边放置相同的颜色，而是要在所有方向上完成两个步骤。

您可以在为图块（a，b）着色时制定规则，而不是从对象中删除颜色。如果a-2 <2，则不再允许该颜色。 x> a + 2和y-2＆lt; y＆lt; B + 2。（在上下2个方格内，左右2个方格）。

然后您必须检查每种颜色的规则（每种颜色可以同时存在多个活动规则，如果0,0和3,0都是红色，则需要fx，您需要当你搬到下一行时，第一条规则仍然存在。）

如果不知道如何实现颜色和网格，就很难详细了解。

编辑再次阅读并注意到我写了y-2＆lt; y＆lt; b-2，第二个 - 应该是+，如上所述。

确保邻居节点不共享相同的值

2 个答案: