Я нашел свой ответ здесь :
$ adb usb
restarting in USB mode
$ adb devices
List of devices attached
######## device
$ adb tcpip 5555
restarting in TCP mode port: 5555
Settings -> About tablet -> Status -> IP address
. Помните IP-адрес формы #.#.#.#.
, иногда его невозможно найти IP-адрес устройства Android, как в моем случае. поэтому вы можете получить его с помощью adb следующим образом: $ adb shell netcfg и должен быть в последней строке результата. $ adb connect #.#.#.#
connected to #.#.#.#:5555
$ adb devices
List of devices attached
#.#.#.#:5555 device
Теперь вы готовы!
Если adb соединение будет потеряно:
adb kill-server
, а затем начните с начала.
Я согласен с более ранними ответами о том, что реальная случайность в небольших тиражах некоторых игр нежелательна - для некоторых случаев использования она кажется слишком несправедливой.
Я написал простую сумку в случайном порядке, как в Ruby, и сделал некоторые тесты. Реализация сделала это:
Это считается несправедливым на основе граничных вероятностей. Например, для вероятности 20% вы можете установить 10% в качестве нижней границы и 40% в качестве верхней границы.
Используя эти границы, я обнаружил, что с прогонами 10 ударов 14,2% время, когда истинная псевдослучайная реализация дала результаты, которые были вне этих границ. Примерно в 11% случаев, 0 критических ударов были забиты в 10 попытках. 3,3% времени, 5 или более критических ударов были высажены из 10. Естественно, используя этот алгоритм (с минимальным количеством рулонов 5), гораздо меньшее количество (0,03%) пробелов «Fairish» было за пределами границ , Даже если приведенная ниже реализация не подходит (возможно, более умные вещи можно сделать, конечно), стоит отметить, что часто пользователи могут почувствовать, что это несправедливо с реальным псевдослучайным решением.
Вот мясо мой FairishBag
написан на Ruby.
def fire!
hit = if @rolls >= @min_rolls && observed_probability > @unfair_high
false
elsif @rolls >= @min_rolls && observed_probability < @unfair_low
true
else
rand <= @probability
end
@hits += 1 if hit
@rolls += 1
return hit
end
def observed_probability
@hits.to_f / @rolls
end
Обновление: использование этого метода увеличивает общую вероятность получения критического удара, примерно до 22%, используя границы выше. Вы можете компенсировать это, установив свою «реальную» вероятность немного ниже. Вероятность 17,5% с помощью волшебной модификации дает наблюдаемую долгосрочную вероятность около 20% и сохраняет справедливость в краткосрочной перспективе.
Что делать с критической зависимостью от последних N атак. Одна простая схема - это какая-то цепочка марков: http://en.wikipedia.org/wiki/Markov_chain , но код очень прост.
IF turns_since_last_critical < M THEN
critial = false
turns_since_last_critical++;
ELSE
critial = IsCritical(chance);
IF Critial THEN
turns_since_last_critica = 0;
ELSE
turns_since_last_critica++;
END IF;
END IF;
Конечно, вы должны сделать свою математику, потому что вероятность критического значения ниже шанса критического, когда вы знаете, что было достаточно поворотов с последнего
[/g0]
это действительно предсказуемо ... но вы никогда не можете быть уверены.
Хорошо, если вы немного разбираетесь в математике, вы можете попробовать Экспоненциальное распределение
Например, если lambda = 0.5, ожидаемое значение равно 2 (go читать эту статью !), означает, что вы, скорее всего, нажмете / критик / независимо от того, на какой-нибудь второй ход (например, 50%, да?). Но с таким распределением вероятностей вы будете определенно промахиваться (или делать что-то противоположное) на 0-м повороте (тот, в котором событие уже произошло, и turn_counter был сброшен), имеют 40% шанс попасть в следующий ход, около 65% шанс сделать это 2-й (следующий после следующего) поворот, около 80% на 3-й и т. д.
Вся цель этого распределения - если у кого есть шанс на 50% шанс, и он пропускает 3 раза в подряд, он wire shurely (ну, более 80% шанс, и он увеличивается каждый следующий ход).
Принимая 20% -ный шанс крита, у вас есть
Его еще около 0,2% (против этих 5%) шансов 3 крита + 2 некрита в 5 последующих поворотах. И есть 14% вероятность 4 последующих некритов, 5% из 5, 1,5% для 6, 0,3% за 7,07% за 8 последующих некритов. Я уверен, что это «более справедливо», чем 41%, 32%, 26%, 21% и 16%.
Надеюсь, вам до сих пор не надоело до смерти.
OP,
Довольно много, если вы хотите, чтобы это было честно, это не будет случайным.
Проблема вашей игры - это фактическая длина матча. Чем длиннее совпадение, тем меньше случайности вы увидите (криты будут составлять 20%) и приближаются к вашим намеченным значениям.
У вас есть два варианта, предварительно рассчитанные атаки, основанные на предыдущих рулонах. Который вы получите один крит каждые 5 атак (на основе ваших 20%), но вы можете сделать порядок случайным.
listOfFollowingAttacks = {Hit, Hit, Hit, Miss, Crit};
Это шаблон, который вы хотите. Так что сделайте его случайным образом из этого списка, пока он не станет пустым, они его воссоздают.
Это шаблон, который я создал для своей игры, он работает очень хорошо, для чего я хочу.
ваш второй вариант, скорее всего, увеличит вероятность крита, вы, вероятно, увидите более четное число в конце всех атак (предполагая, что ваши матчи заканчиваются довольно быстро). Чем меньше вероятность, тем больше вы получаете RNG.
Предварительно вычислить случайный критический удар для каждого игрока.
// OBJECT
//...
// OnAttack()
//...
c_h = c_h -1;
if ( c_h == 0 ) {
// Yes, critical hit!
c_h = random(5) + 1 // for the next time
// ...
}
Надеюсь, эта статья вам поможет: http://web.archive.org/web/20090103063439/http://www.gamedev.net:80/reference/design/features/randomness/
Этот метод генерации «случайных чисел» распространен в играх rpg / mmorpg.
Задача, которую он решает, - это (выдержка):
] Паук лезвия у вас в горле. Он бьет, и вы пропустите. Он снова бьет, и вы снова пропустите. И снова и снова, пока вам не удастся попасть. Ты мертв, и над твоим трупом раздался двухтонный арахнид. Невозможно? Нет. Невероятно? Да. Но, учитывая достаточно игроков и учитывая достаточно времени, невероятное становится почти уверенным. Дело не в том, что лезвие паука было трудным, это была просто невезение. Как расстраивает. Этого достаточно, чтобы заставить игрока отказаться.
blockquote>
Это означает, что 1 из 5 ударов должен быть критическим. Проблема в том, что у меня очень плохие результаты в реальной жизни - иногда игроки получают 3 крита в 5 ударах, иногда ни один из 15 попаданий.
blockquote>Что вам нужно сумка в случайном порядке . Это решает проблему истинного случайного, слишком случайного для игр.
Алгоритм выглядит примерно так: вы помещаете 1 критический и 4 некритических попадания в сумку. Затем вы производите свой заказ в сумке и выбираете их по одному. Когда сумка пуста, вы снова заполняете ее теми же значениями и производите ее. Таким образом, вы получите в среднем 1 критический удар за 5 ударов и не более 2 критических и 8 некритических ударов подряд. Увеличьте количество предметов в сумке для большей случайности.
Ниже приведен пример реализации (в Java) и его тестовых случаях , что I написал некоторое время назад.
Учитывая поведение, о котором вы просите, я думаю, что вы рандомизировали неверную переменную.
Вместо того, чтобы рандомизировать, будет ли ударом критически, попробуйте рандомизировать число до следующего критического попадания. Например, просто выберите число между 2 & amp; 9 каждый раз, когда игрок получает критический момент, а затем дает им следующий критический после того, как прошло много раундов. Вы также можете использовать методы кубиков, чтобы приблизиться к нормальному распределению - например, вы получите следующий критический момент в 2D4 оборотах.
Я считаю, что эта техника используется в RPG, которые имеют случайные встречи в мире а также - вы производите счетчик шагов, а после этого много шагов, вы снова получаете удар. Он чувствует себя намного более справедливым, потому что вы почти никогда не попадаете в два столкновения подряд - если это происходит даже один раз, игроки становятся раздражительными.
Я думаю, что вы используете неправильную функцию случайного распределения. Вы, вероятно, не хотите равномерного распределения по номерам. Попробуйте обычное распределение вместо этого, чтобы критические попадания стали более необычными, чем «регулярные» хиты.
Я работаю с Java, поэтому я не уверен, где вы можете найти что-то для C ++, что дает вам случайные числа с нормальное распределение, но должно быть что-то там.
У Города Героев действительно есть механик, называемый «полосатой», который решает именно эту проблему. Способ, которым он работает, состоит в том, что после последовательности промахов длины, связанной с наименьшей вероятностью попадания в строку, следующая атака гарантированно станет хитом. Например, если вы пропустите атаку с более чем 90%, чтобы нанести удар, тогда ваша следующая атака будет автоматически ударяться, но если ваш шанс попадания будет ниже, чем 60%, тогда вам нужно будет иметь несколько последовательных промахов, чтобы вызвать «полосатор» (I не знаю точных чисел)
Вы смотрите на линейное распределение, когда вы, вероятно, хотите нормальное распространение.
Если вы помните, как в юности играли D & amp; D, вас попросили перевернуть несколько n-сторонних штампов, затем суммируйте результаты.
Например, прокатка 4 x 6-сторонняя матрица отличается от прокатки 1 x 24-сторонних кубиков.
За такое небольшое количество тестов вы должны ожидать таких результатов:
Истинная случайность только предсказуема над огромным размером набора, так что вполне возможно перевернуть монету и получить 3 раза в голову сначала в строке, но в течение нескольких миллионов флип вам в итоге будет 50-50.
Реакция на: «Проблема в том, что у меня очень плохие результаты в реальной жизни - иногда игроки получают 3 крита в 5 хитов, иногда ни один из 15 хитов».
У вас есть шанс где-то между 3 и 4% ничего не получают в 15 хитов ...
Не совсем понятно, что вы хотите. Можно создать такую функцию, чтобы первые 5 раз вы ее вызывали, она возвращает числа 1-5 в случайном порядке.
Но это не случайно. Игрок будет знать, что он получит ровно 5 в следующих 5 атаках. Это может быть то, что вы хотите, хотя, и в этом случае вам просто нужно закодировать его самостоятельно. (создайте массив, содержащий числа, а затем перетасуйте их).
В качестве альтернативы вы можете продолжать использовать свой текущий подход и считаете, что ваши текущие результаты вызваны неправильным случайным генератором. Обратите внимание, что с вашими текущими номерами ничего не может быть. Случайные значения случайны. иногда вы получаете 2, 3 или 8 одного и того же значения в строке. Потому что они случайные. Хороший случайный генератор просто гарантирует, что в среднем все числа будут возвращаться одинаково часто.
Конечно, если вы использовали плохой случайный генератор, это могло бы исказить ваши результаты, и если да, просто переключение на лучший случайный генератор должно устранить проблему. (Посмотрите библиотеку Boost.Random для лучших генераторов)
В качестве альтернативы вы могли бы вспомнить последние N значений, возвращаемых вашей случайной функцией, и взвесить результат на них. (простой пример был бы «для каждого появления нового результата есть 50% -ный шанс, мы должны отказаться от значения и получить новый»
Если бы я должен был догадаться, я бы сказал, с «фактической» случайностью - ваш лучший выбор. Убедитесь, что вы используете хороший генератор случайных чисел, а затем продолжайте идти так, как вы делаете это сейчас.
Несомненно, любая генерация случайных чисел имеет шанс произвести такие прогоны? Вы не получите достаточно большой набор образцов в 3-10 рулонах, чтобы увидеть соответствующие проценты.
Возможно, что вы хотите, это порог милосердия ... помните последние 10 рулонов, и если они У меня был критический удар, дайте им халяву. Сгладьте стропы и стрелы случайности.
Если вам нужен дистрибутив, который предотвращает повторные значения, вы можете использовать простой алгоритм повторного отклонения.
, например
int GetRand(int nSize)
{
return 1 + (::rand() % nSize);
}
int GetDice()
{
static int nPrevious=-1;
while (1) {
int nValue = GetRand(6);
// only allow repeat 5% of the time
if (nValue==nPrevious && GetRand(100)<95)
continue;
nPrevious = nValue;
return nValue;
}
}
Этот код отклоняет значения повторения 95% времени , что делает повторения маловероятными, но не невозможными. Статистически это немного уродливо, но это, вероятно, даст желаемые результаты. Конечно, это не помешает распространению вроде «5 4 5 4 5». Вы могли бы стать фаворитом и отказаться от второго последнего (скажем) 60% времени и третьего последнего (скажем) 30%.
Я не рекомендую это как хороший игровой дизайн. Просто предлагая, как добиться того, чего вы хотите.
Лучшие ответы - это отличные объяснения, поэтому я просто сосредоточусь на алгоритме, который дает вам возможность контролировать вероятность «плохих полос», в то время как никогда не становится детерминированным. Вот что, я думаю, вы должны сделать:
Вместо указания p параметр распределения Бернулли, который является вашей вероятностью критического попадания, указывает a и b , параметры бета-распределения, «сопряженные до» распределения Бернулли. Вам нужно отслеживать A и B , количество критических и некритических ударов до сих пор.
Теперь, чтобы указать a и b , убедитесь, что a / (a + b) = p, вероятность критического попадания. Оптимальным является то, что (a + b) количественно определяет, насколько близко вы хотите, чтобы A / (A + B) был равным p.
Вы делаете свою выборку следующим образом:
пусть p(x)
- функция плотности вероятности бета-распределения. Он доступен во многих местах, но вы можете найти его в GSL как gsl_ran_beta_pdf.
S = A+B+1
p_1 = p((A+1)/S)
p_2 = p(A/S)
Выберите критический удар по выборке из распределения bernoulli с вероятностью p_1 / (p_1 + p_2)
Если вы обнаружите, что в случайных числах слишком много «плохих полос», , увеличьте a и b , но в пределе, поскольку a и b переходят в бесконечность, вы будете перед тем, как описано выше, используйте описанный метод перемешивания.
Если вы реализуете это, пожалуйста, дайте мне знать, как это делается!
К сожалению, то, о чем вы просите, является генератором неслучайных чисел - потому что вы хотите, чтобы предыдущие результаты учитывались при определении следующего числа. Это не то, как работают генераторы случайных чисел.
Если вы хотите, чтобы 1 из каждых 5 хитов был критическим, просто выберите число от 1 до 5 и скажите, что этот удар будет критический.
Я бы предложил следующую «случайную задержку с удержанием»:
in-array
), первоначально заполненный значениями от 0 до n-1, другой ( out-array
) empty in-array
, переместите это значение с in-array
на out-array
, переместите один (по всем элементам, включая неопределенный!) элемент из out-array
обратно в in-array
Это свойство обладает тем, что оно будет «реагировать» больше медленно больше n . Например, если вы хотите 20% -ный шанс, установка n на 5 и нажатие на 0 является «менее случайным», чем установка n до 10 и нажатие на 0 или 1, и от 0 до 199 из 1000 будет почти неотличим от истинной случайности над небольшим образцом. Вам нужно будет отрегулировать n на ваш размер выборки.
Как насчет взвешивания значения?
Например, если у вас есть 20% вероятность критического попадания, сгенерируйте число от 1 до 5 с одним числом, представляющим критический удар, или числом между 1 и 100, причем 20 чисел являются критическим.
Но пока вы работаете со случайными или псевдослучайными номерами, нет возможности потенциально избежать результатов, которые вы сейчас видите. Это характер случайности.
Я рекомендую прогрессивную процентную систему, например Blizzard: http://www.shacknews.com/onearticle.x/57886
Как правило, вы запускаете RNG, затем сравниваете его к значению для определения успеха или нет. Это может выглядеть так:
if ( randNumber <= .2 ) {
//Critical
} else {
//Normal
}
Все, что вам нужно сделать, это добавить прогрессивное увеличение базового шанса ...
if (randNumber <= .2 + progressiveChance ) {
progressiveChance = 0;
//Critical
} else {
progressiveChance += CHANCE_MODIFIER;
//Normal hit
}
Если вам нужно, чтобы он был более причудливым его довольно легко добавить больше. Вы можете ограничить количество, которое progressiveChance может получить, чтобы избежать 100% -ной критической вероятности или сбросить его на определенные события. Вы также можете увеличить progressiveChance в меньших количествах с каждым повышением с помощью чего-то вроде progressiveChance + = (1 - progressiveChance) * SCALE, где SCALE & lt; 1.