Об'єднання багатьох малих колайдерів у більші


13

Я створюю гру, використовуючи плиткову карту з багатьох тисяч сітчастих квадратів. На даний момент кожен квадрат має на ньому квадратний колайдер для перевірки зіткнень.

введіть тут опис зображення

Однак із багатьма тисячами крихітних блоків перевірка їх на предмет зіткнень неефективна. Якби я знав, що мапа плитки буде виглядати так заздалегідь, я міг би просто використати 3 або 4 великих коллайдера, а не тисячі крихітних:

введіть тут опис зображення

Чи існує якийсь стандартний алгоритм поєднання багатьох малих сусідніх плиток у максимально великі? Якщо так, то хтось може це описати тут, або вказати на літературу про такі алгоритми?

Як альтернатива, можливо, попередньо обробити плиткові колайдери таким способом є абсолютно неправильним підходом. Якщо так, то як правильно впоратися з ефективністю надзвичайно великої кількості колайдерів?


Чи плануєте ви зруйнувати місцевість?
jgallant

@Jon. Я цього не розглядав. Я думаю, що можливість руйнування може значно ускладнити проблему (оскільки один з маленьких колайдерів може бути знищений, тобто великі комбіновані колайдери потрібно буде перерахувати, правда?)
Крейг Іннс

Так. Ось чому я питав. Як правило, ви б поєднали всю свою місцевість у сітку. Якщо ви плануєте дозволити руйнуванню своєї місцевості, існує інший метод, який можна використовувати, який встановлює коліктори лише на зовнішні блоки. Ви б попередньо обчислити, які блоки є "крайніми блоками", а потім призначити ці блоки за допомогою збірного колайдера. ( jgallant.com/images/uranus/chunk.png - Зображення старе і не ідеальне, але демонструє техніку) Що ви використовуєте для ігрового двигуна / платформи?
jgallant

@Jon Я використовую Unity в якості свого ігрового двигуна з компонентами BoxCollider2D для зіткнень плитки. Я не згадував про свою конкретну платформу, оскільки вважав, що це може бути кориснішим для обміну стеками ігор для розробників, щоб отримати більш загальну відповідь на цю проблему. Що стосується вашого методу "крайні блоки", чи можете ви надіслати відповідь із точними деталями алгоритму цього методу? Або у вас є посилання на ресурси щодо таких методів?
Крейг Іннес

1
У мене є реалізація Unity для цього, мені знадобиться певний час, щоб зробити написання, оскільки воно насправді не ріжеться і не сушиться. Наразі я на роботі, а вихідний код є вдома. Якщо ви можете зачекати до сьогоднішньої ночі відповіді. Ось як це виглядає: jgallant.com/images/landgen.gif
jgallant

Відповіді:


5

Я знайшов корисний цей алгоритм для двигуна love2d ( мова луа )

https://love2d.org/wiki/TileMerging

-- map_width and map_height are the dimensions of the map
-- is_wall_f checks if a tile is a wall

local rectangles = {} -- Each rectangle covers a grid of wall tiles

for x = 0, map_width - 1 do
    local start_y
    local end_y

    for y = 0, map_height - 1 do
        if is_wall_f(x, y) then
            if not start_y then
                start_y = y
            end
            end_y = y
        elseif start_y then
            local overlaps = {}
            for _, r in ipairs(rectangles) do
                if (r.end_x == x - 1)
                  and (start_y <= r.start_y)
                  and (end_y >= r.end_y) then
                    table.insert(overlaps, r)
                end
            end
            table.sort(
                overlaps,
                function (a, b)
                    return a.start_y < b.start_y
                end
            )

            for _, r in ipairs(overlaps) do
                if start_y < r.start_y then
                    local new_rect = {
                        start_x = x,
                        start_y = start_y,
                        end_x = x,
                        end_y = r.start_y - 1
                    }
                    table.insert(rectangles, new_rect)
                    start_y = r.start_y
                end

                if start_y == r.start_y then
                    r.end_x = r.end_x + 1

                    if end_y == r.end_y then
                        start_y = nil
                        end_y = nil
                    elseif end_y > r.end_y then
                        start_y = r.end_y + 1
                    end
                end
            end

            if start_y then
                local new_rect = {
                    start_x = x,
                    start_y = start_y,
                    end_x = x,
                    end_y = end_y
                }
                table.insert(rectangles, new_rect)

                start_y = nil
                end_y = nil
            end
        end
    end

    if start_y then
        local new_rect = {
            start_x = x,
            start_y = start_y,
            end_x = x,
            end_y = end_y
        }
        table.insert(rectangles, new_rect)

        start_y = nil
        end_y = nil
    end
end
Here's how the rectangles would be used for physics.
-- Use contents of rectangles to create physics bodies
-- phys_world is the world, wall_rects is the list of...
-- wall rectangles

for _, r in ipairs(rectangles) do
    local start_x = r.start_x * TILE_SIZE
    local start_y = r.start_y * TILE_SIZE
    local width = (r.end_x - r.start_x + 1) * TILE_SIZE
    local height = (r.end_y - r.start_y + 1) * TILE_SIZE

    local x = start_x + (width / 2)
    local y = start_y + (height / 2)

    local body = love.physics.newBody(phys_world, x, y, 0, 0)
    local shape = love.physics.newRectangleShape(body, 0, 0,
      width, height)

    shape:setFriction(0)

    table.insert(wall_rects, {body = body, shape = shape})
end

Ось наступний приклад love2d мого поточного проекту. Червоним кольором ви бачите мої настінні коллайдери

введіть тут опис зображення


Чи є версія C #? Чи є версія з коментарями до документації? Чи можна цей алгоритм адаптувати для 3D?
Аарон Франке

3

Якщо ви хочете створити руйнуючий ландшафт, то, як я це робив в Unity, полягає в тому, щоб встановити тільки коліктори на крайніх блоках вашого світу. Так, наприклад, ви хочете досягти цього:

Зелені блоки позначають плитки, що містять колайдер

Усі ці зелені блоки містять коллайдер, а решта - ні. Це економить тонну на обчисленнях. Якщо ви знищите блок, ви можете активувати протистояння на сусідніх блоках досить легко. Майте на увазі, що активація / деактивація коллайдера дорога і повинна здійснюватися неефективно.

Отже, ресурс Tile виглядає приблизно так:

Ресурс плитки в єдності

Це стандартний ігровий об'єкт, але він також є об'єднаним. Також зауважте, що бойовий колайдер за замовчуванням встановлено вимкненим. Ми активуватимемо лише якщо це крайова плитка.

Якщо ви статично завантажуєте свій світ, немає необхідності в об'єднанні вашої плитки. Ви можете просто завантажити їх одним пострілом, обчислити їх відстань від краю і, якщо потрібно, застосувати колайдер.

Якщо ви завантажуєте динамічно, найкраще використовувати басейн для плитки. Ось відредагований приклад моєї петлі оновлення. Він завантажує плитки на основі поточного перегляду камери:

public void Refresh(Rect view)
{       
    //Each Tile in the world uses 1 Unity Unit
    //Based on the passed in Rect, we calc the start and end X/Y values of the tiles presently on screen        
    int startx = view.x < 0 ? (int)(view.x + (-view.x % (1)) - 1) : (int)(view.x - (view.x % (1)));
    int starty = view.y < 0 ? (int)(view.y + (-view.y % (1)) - 1) : (int)(view.y - (view.y % (1)));

    int endx = startx + (int)(view.width);
    int endy = starty - (int)(view.height);

    int width = endx - startx;
    int height = starty - endy;

    //Create a disposable hashset to store the tiles that are currently in view
    HashSet<Tile> InCurrentView = new HashSet<Tile>();

    //Loop through all the visible tiles
    for (int i = startx; i <= endx; i += 1)
    {
        for (int j = starty; j >= endy; j -= 1)
        {
            int x = i - startx;
            int y = starty - j;

            if (j > 0 && j < Height)
            {
                //Get Tile (I wrap my world, that is why I have this mod here)
                Tile tile = Blocks[Helper.mod(i, Width), j];

                //Add tile to the current view
                InCurrentView.Add(tile);

                //Load tile if needed
                if (!tile.Blank)
                {
                    if (!LoadedTiles.Contains(tile))
                    {                           
                        if (TilePool.AvailableCount > 0)
                        {
                            //Grab a tile from the pool
                            Pool<PoolableGameObject>.Node node = TilePool.Get();

                            //Disable the collider if we are not at the edge
                            if (tile.EdgeDistance != 1)
                                node.Item.GO.GetComponent<BoxCollider2D>().enabled = false;

                            //Update tile rendering details
                            node.Item.Set(tile, new Vector2(i, j), DirtSprites[tile.TextureID], tile.Collidable, tile.Blank);
                            tile.PoolableGameObject = node;
                            node.Item.Refresh(tile);

                            //Tile is now loaded, add to LoadedTiles hashset
                            LoadedTiles.Add(tile);

                            //if Tile is edge block, then we enable the collider
                            if (tile.Collidable && tile.EdgeDistance == 1)
                                node.Item.GO.GetComponent<BoxCollider2D>().enabled = true;
                        }
                    }                       
                }                  
            }
        }
    }

    //Get a list of tiles that are no longer in the view
    HashSet<Tile> ToRemove = new HashSet<Tile>();
    foreach (Tile tile in LoadedTiles)
    {
        if (!InCurrentView.Contains(tile))
        {
            ToRemove.Add(tile);
        }
    }

    //Return these tiles to the Pool 
    //this would be the simplest form of cleanup -- Ideally you would do this based on the distance of the tile from the viewport
    foreach (Tile tile in ToRemove)
    {
        LoadedTiles.Remove(tile);
        tile.PoolableGameObject.Item.GO.GetComponent<BoxCollider2D>().enabled = false;
        tile.PoolableGameObject.Item.GO.transform.position = new Vector2(Int32.MinValue, Int32.MinValue);
        TilePool.Return(tile.PoolableGameObject);            
    }

    LastView = view;
}

В ідеалі я б написав набагато докладніший пост, оскільки за кулісами відбувається дещо більше. Однак це може вам допомогти. Якщо є питання, не соромтеся запитати або зв'яжіться зі мною.


Прийнято відповідь dnkdrone, оскільки він безпосередньо відповідає на поставлене оригінальне запитання. Однак відповіли на цю відповідь, оскільки вона дає цінні вказівки на ефективну альтернативу
Крейг Інс

@CraigInnes Не має жодних проблем. Так само, як допомогти. Очки не мають значення :)
jgallant
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.