Выбор рандомного юнита (числа, области, в целом не важно)

На картинке у вас каждого героя может атаковать только один другой герой, это тоже учитывается?

Создаем 3 переменные отряд. ТЕСТ_А, ТЕСТ_B, ТЕСТ_С
Предварительно в группу ТЕСТ_А включаем всех основных героев, в группу ТЕСТ_B включаем все копии.
Далее, триггер:

Hero_mechanic - это просто переменная юнита из моей карты) Можно сделать любую другую.

prog:

DarkLigthing, Lord_Teo, вы оба не учитываете коллизию, которая может возникнуть, если последние двое оставшихся будут одного и того же типа, что нарушает условие согласно которому копии не должны атаковать оригинал.

Какая коллизия, вы че?! Там действие: атаковать случайного! Просто будут несколько героев атаковать одного.

prog:

Lord_Teo, это в любом случае не решает поставленную автором вопроса задачу.

Если быть внимательнее, то про 1 на 1 было только в комментарии. В первом вопросе такого условия не было

---

respect_gg:

В этом и проблема, чувак :) Должно быть примерно так же, как на картинке. Юниты были изображены лишь для простоты объяснения проблемы. В целом работа идет с ID игроков

Ну, надо было яснее выражаться сразу) Тогда я сдаюсь)))

Согласен с prog, проще сравнить только последнюю пару и поменять в случае совпадения

respect_gg, ну так кто тебе мешает сперва циклом пройтись по массиву то, а не сразу действия делать?

---

Еще раз повторю суть своей идеи.

1. Сперва тасуем массив индексов так чтобы они заняли случайные позиции отличные от своих собственных. Алгоритм выстраивается так, чтобы только последняя оставшаяся пара могла быть коллизией.
2. В конце - проверяем последнюю пару, если она является коллизией, то выбираем случайную другую пару и меняем местами.
3. Проходим по массиву еще раз, в этот раз уже выполняя нужные действия.

respect_gg, можно вобще вот так

1. записываем в массив номера от 0 до N где N это число игроков минус один в ячейки с соответствующими номерами
2. проходим циклом от N до 0, пусть номер итерации будет i
3. на каждой итерации получаем случайное число R от 0 до N, Если оно совпало с i, то берем i+1 или i-1, с учетом границ
4. меняем местами ячейки R и i
5. если в ячейку i в результате обмена опять попало число с номером этой ячейки, делаем еще один случайный обмен (тут можно не делать дополнительную проверку на коллизию т.к. коллизия не может на этом этапе возникнуть повторно для этой ячейки)

Если я ничего не напутал - получаем на выходе массив чисел в котором числа не повторяются и не находятся в ячейках совпадающих со своим номером.

Использовать это потом - номер ячейки это один игрок, число в ячейке - другой.

Если нужен учет того что игроки могут иметь номера не идущие подряд (ливеры, компьютеры, просто игроки не использующиеся в этой системе) - нам понадобится дополнительный массив с номерами игроков, чтобы превратить номер ячейки и число в ячейке в реальный номер игрока.

respect_gg, я уже описал как решить проблему ливеров...
Нам всего-то надо знать сколько живых игроков, это будет N.
Пусть массив с номерами будет Numbers. Пока оставим его пустым.
Берем второй массив, назовем его Index. В Index записываем айдишники живых игроков, сколько бы их ни было, заодно в процессе вычисляем N и заполняем массив Numbers порядковыми номерами от 0 до N.
Выполняем алгоритм из поста выше.
Результат выполнения алгоритма используем так - проходим циклом от 0 до N, с номером итерации j
Index[Number[j]] - один игрок
Index[j] - второй игрок

respect_gg, алгоритм рабочий, хоть и требует одной маленькой доработки перед финальным использованием, а твой чувак не шарит и, похоже, ничерта не понял в алгоритме, начиная с того, зачем в нем нужны смещения. Первое "смещение" - N = кол-во игроков -1 нужно потому как нумерация от 0 до N включительно. Второе смещение +1 или -1 на некоторых итерациях нужно чтобы рандом не выдал ту-же ячейку в которой алгоритм находится в текущей итерации, это не более чем дешевое исключение ячейки из диапазона рандома.

Впрочем, поскольку ты даже не попытался реализовать этот алгоритм на практике или разобраться в принципах его работы, а сразу заклеймил его не рабочим - я умываю руки. Это будет мое последнее сообщение в этой теме.

Вот тебе алгоритм для твоего уровня, если нормальный не получается осилить:
Вместо перемешивания сдвигай всех на одно и то же случайное число один раз, с сохранением порядка. Это не так круто как полное перемешивание, но никто и не заметит если сдвиг будет рандомный каждый раз. Естественно, с использованием двух массивов, как я описал выше, чтобы исключить ливеров. Если и до этого не допрешь сам - спроси своего друга якобы шарящего в C++, может хоть с этим он справится.

На всякий случай даже подробно разжую:

Перебираешь игроков, тех кто жив записываешь в массив Index. В результате на выходе получаешь массив, в котором в первой ячейке номер первого живого игрока, во второй - номер второго живого игрока - не и важно какие это игроки по номеру - первый живой может быть пятым, а второй восьмым, тогда первая ячейка будет равна пяти, вторая восьми. Так-же нужно посчитать сколько всего их, живых игроков, это тоже удобно сделать тут, пусть это будет число P. А N, как и раньше, будет P-1.
Каким-угодно способом заполняешь массив Numbers числами от 0 и до N, так чтобы в каждой ячейке изначально был её номер.
Потом один раз берешь случайное число R, оно может быть любым, но важно чтобы оно не было кратным P.
Потом прибавляешь к каждой ячейке Numbers это число - R. Еще раз подчеркиваю - R для всех ячеек одинаковое.
Если в результате число в ячейке больше или равно P, то вычитаешь из него P пока оно не станет меньше P.
На этом заканчиваешь работу с массивом Numbers.

Теперь можно как-то использовать полученный массив, а именно:
Циклом от 0 до N проходим с индексом j
в цикле переменной k присваиваем Number[j]
и получаем номера для двух игроков из массива Index
Index[k] и Index[j]

Этот алгоритм тоже с подвохом, просьба тем кто его заметил не раскрывать карты раньше времени