/* ------------ Methods for handling particle depletion -------------- */
std::vector<std::unique_ptr<State>> Model::generateParticles(
BeliefNode *previousBelief, Action const &action, Observation const &obs, long nParticles,
std::vector<State const *> const &previousParticles) {
double startTime = tapir::clock_ms();
double endTime = startTime + 10000.0;
std::vector<std::unique_ptr<State>> particles;
ObservationMapping *obsMap = previousBelief->getMapping()->getActionNode(action)->getMapping();
BeliefNode *childNode = obsMap->getBelief(obs);
// Use rejection sampling to generate the required number of particles.
while ((long)particles.size() < nParticles) {
if (tapir::clock_ms() >= endTime) {
cout << "WARNING: Timeout while replenishing particles" << endl;
return particles;
}
// Sample a random particle.
if (previousParticles.size() == 0) {
cout << "Previous particle set is empty!!!!!" << endl;
}
long index = std::uniform_int_distribution<long>(0,
previousParticles.size() - 1)(*getRandomGenerator());
State const *state = previousParticles[index];
// Now generate a step in the model, and compare the observation to the actual observation.
// Note that this comparison is done implicitly via the observation mapping, to ensure
// that approximate observations are treated cleanly.
StepResult result = generateStep(*state, action);
if (obsMap->getBelief(*result.observation) == childNode) {
particles.push_back(std::move(result.nextState));
}
}
return particles;
}
void Dropout(Tensor tensor, float dropProb) {
auto cpuBackend
= std::static_pointer_cast<cpu::Backend>(tensor->getBackend());
auto &gen = cpuBackend->getRandomGenerator();
std::bernoulli_distribution dist(1.f - dropProb);
std::generate(tensor->data(), tensor->data() + tensor->size(), [&]() {
return (float)dist(gen) / (1.f - dropProb);
});
}
int32_t normal_random(int32_t minNumber, int32_t maxNumber)
{
static std::normal_distribution<float> normalRand(0.5f, 0.25f);
if (minNumber == maxNumber) {
return minNumber;
} else if (minNumber > maxNumber) {
std::swap(minNumber, maxNumber);
}
return minNumber + std::max<float>(0.f, std::min<float>(1.f, normalRand(getRandomGenerator()))) * (maxNumber - minNumber);
}
int32_t uniform_random(int32_t minNumber, int32_t maxNumber)
{
static std::uniform_int_distribution<int32_t> uniformRand;
if (minNumber == maxNumber) {
return minNumber;
} else if (minNumber > maxNumber) {
std::swap(minNumber, maxNumber);
}
return uniformRand(getRandomGenerator(), std::uniform_int_distribution<int32_t>::param_type(minNumber, maxNumber));
}
bool Monster::getRandomStep(const Position& creaturePos, Direction& direction) const
{
static std::vector<Direction> dirList{
DIRECTION_NORTH,
DIRECTION_WEST, DIRECTION_EAST,
DIRECTION_SOUTH
};
std::shuffle(dirList.begin(), dirList.end(), getRandomGenerator());
for (Direction dir : dirList) {
if (canWalkTo(creaturePos, dir)) {
direction = dir;
return true;
}
}
return false;
}
bool Monster::pushCreature(Creature* creature)
{
static std::vector<Direction> dirList {
DIRECTION_NORTH,
DIRECTION_WEST, DIRECTION_EAST,
DIRECTION_SOUTH
};
std::shuffle(dirList.begin(), dirList.end(), getRandomGenerator());
for (Direction dir : dirList) {
const Position& tryPos = Spells::getCasterPosition(creature, dir);
Tile* toTile = g_game.map.getTile(tryPos);
if (toTile && !toTile->hasFlag(TILESTATE_BLOCKPATH)) {
if (g_game.internalMoveCreature(creature, dir) == RETURNVALUE_NOERROR) {
return true;
}
}
}
return false;
}
bool Monster::pushItem(Item* item)
{
const Position& centerPos = item->getPosition();
static std::vector<std::pair<int32_t, int32_t>> relList {
{-1, -1}, {0, -1}, {1, -1},
{-1, 0}, {1, 0},
{-1, 1}, {0, 1}, {1, 1}
};
std::shuffle(relList.begin(), relList.end(), getRandomGenerator());
for (const auto& it : relList) {
Position tryPos(centerPos.x + it.first, centerPos.y + it.second, centerPos.z);
Tile* tile = g_game.map.getTile(tryPos);
if (tile && g_game.canThrowObjectTo(centerPos, tryPos)) {
if (g_game.internalMoveItem(item->getParent(), tile, INDEX_WHEREEVER, item, item->getItemCount(), nullptr) == RETURNVALUE_NOERROR) {
return true;
}
}
}
return false;
}
bool WeaponDistance::useWeapon(Player* player, Item* item, Creature* target) const
{
int32_t damageModifier = playerWeaponCheck(player, target);
if (damageModifier == 0) {
return false;
}
int32_t chance;
if (hitChance == 0) {
//hit chance is based on distance to target and distance skill
uint32_t skill = player->getSkillLevel(SKILL_DISTANCE);
const Position& playerPos = player->getPosition();
const Position& targetPos = target->getPosition();
uint32_t distance = std::max<uint32_t>(Position::getDistanceX(playerPos, targetPos), Position::getDistanceY(playerPos, targetPos));
if (maxHitChance == 75) {
//chance for one-handed weapons
switch (distance) {
case 1:
case 5:
chance = std::min<uint32_t>(skill, 74) + 1;
break;
case 2:
chance = static_cast<uint32_t>(std::min<uint32_t>(skill, 28) * 2.40f) + 8;
break;
case 3:
chance = static_cast<uint32_t>(std::min<uint32_t>(skill, 45) * 1.55f) + 6;
break;
case 4:
chance = static_cast<uint32_t>(std::min<uint32_t>(skill, 58) * 1.25f) + 3;
break;
case 6:
chance = static_cast<uint32_t>(std::min<uint32_t>(skill, 90) * 0.80f) + 3;
break;
case 7:
chance = static_cast<uint32_t>(std::min<uint32_t>(skill, 104) * 0.70f) + 2;
break;
default:
chance = hitChance;
break;
}
} else if (maxHitChance == 90) {
//formula for two-handed weapons
switch (distance) {
case 1:
case 5:
chance = static_cast<uint32_t>(std::min<uint32_t>(skill, 74) * 1.20f) + 1;
break;
case 2:
chance = static_cast<uint32_t>(std::min<uint32_t>(skill, 28) * 3.20f);
break;
case 3:
chance = std::min<uint32_t>(skill, 45) * 2;
break;
case 4:
chance = static_cast<uint32_t>(std::min<uint32_t>(skill, 58) * 1.55f);
break;
case 6:
case 7:
chance = std::min<uint32_t>(skill, 90);
break;
default:
chance = hitChance;
break;
}
} else if (maxHitChance == 100) {
switch (distance) {
case 1:
case 5:
chance = static_cast<uint32_t>(std::min<uint32_t>(skill, 73) * 1.35f) + 1;
break;
case 2:
chance = static_cast<uint32_t>(std::min<uint32_t>(skill, 30) * 3.20f) + 4;
break;
case 3:
chance = static_cast<uint32_t>(std::min<uint32_t>(skill, 48) * 2.05f) + 2;
break;
case 4:
chance = static_cast<uint32_t>(std::min<uint32_t>(skill, 65) * 1.50f) + 2;
break;
case 6:
chance = static_cast<uint32_t>(std::min<uint32_t>(skill, 87) * 1.20f) - 4;
break;
case 7:
chance = static_cast<uint32_t>(std::min<uint32_t>(skill, 90) * 1.10f) + 1;
break;
default:
chance = hitChance;
break;
}
} else {
chance = maxHitChance;
}
} else {
chance = hitChance;
}
if (item->getWeaponType() == WEAPON_AMMO) {
Item* bow = player->getWeapon(true);
if (bow && bow->getHitChance() != 0) {
chance += bow->getHitChance();
}
}
if (chance >= uniform_random(1, 100)) {
Weapon::internalUseWeapon(player, item, target, damageModifier);
} else {
//miss target
Tile* destTile = target->getTile();
if (!Position::areInRange<1, 1, 0>(player->getPosition(), target->getPosition())) {
static std::vector<std::pair<int32_t, int32_t>> destList {
{-1, -1}, {0, -1}, {1, -1},
{-1, 0}, {0, 0}, {1, 0},
{-1, 1}, {0, 1}, {1, 1}
};
std::shuffle(destList.begin(), destList.end(), getRandomGenerator());
Position destPos = target->getPosition();
for (const auto& dir : destList) {
Tile* tmpTile = g_game.map.getTile(destPos.x + dir.first, destPos.y + dir.second, destPos.z);
// Blocking tiles or tiles without ground ain't valid targets for spears
if (tmpTile && !tmpTile->hasProperty(CONST_PROP_IMMOVABLEBLOCKSOLID) && tmpTile->ground != nullptr) {
destTile = tmpTile;
break;
}
}
}
Weapon::internalUseWeapon(player, item, destTile);
}
return true;
}
solver::StateInfo * Model::sampleParticle(const std::vector<solver::StateInfo *> &stateInfos) {
RandomGenerator *randGen = getRandomGenerator();
long index = std::uniform_int_distribution<long>(0, stateInfos.size() - 1)(*randGen);
return stateInfos[index];
}
bool boolean_random(double probability/* = 0.5*/)
{
static std::bernoulli_distribution booleanRand;
return booleanRand(getRandomGenerator(), std::bernoulli_distribution::param_type(probability));
}
bool Monster::getDanceStep(const Position& creaturePos, Direction& direction,
bool keepAttack /*= true*/, bool keepDistance /*= true*/)
{
bool canDoAttackNow = canUseAttack(creaturePos, attackedCreature);
assert(attackedCreature != nullptr);
const Position& centerPos = attackedCreature->getPosition();
int_fast32_t offset_x = Position::getOffsetX(creaturePos, centerPos);
int_fast32_t offset_y = Position::getOffsetY(creaturePos, centerPos);
int_fast32_t distance_x = std::abs(offset_x);
int_fast32_t distance_y = std::abs(offset_y);
uint32_t centerToDist = std::max<uint32_t>(distance_x, distance_y);
std::vector<Direction> dirList;
if (!keepDistance || offset_y >= 0) {
uint32_t tmpDist = std::max<uint32_t>(distance_x, std::abs((creaturePos.getY() - 1) - centerPos.getY()));
if (tmpDist == centerToDist && canWalkTo(creaturePos, DIRECTION_NORTH)) {
bool result = true;
if (keepAttack) {
result = (!canDoAttackNow || canUseAttack(Position(creaturePos.x, creaturePos.y - 1, creaturePos.z), attackedCreature));
}
if (result) {
dirList.push_back(DIRECTION_NORTH);
}
}
}
if (!keepDistance || offset_y <= 0) {
uint32_t tmpDist = std::max<uint32_t>(distance_x, std::abs((creaturePos.getY() + 1) - centerPos.getY()));
if (tmpDist == centerToDist && canWalkTo(creaturePos, DIRECTION_SOUTH)) {
bool result = true;
if (keepAttack) {
result = (!canDoAttackNow || canUseAttack(Position(creaturePos.x, creaturePos.y + 1, creaturePos.z), attackedCreature));
}
if (result) {
dirList.push_back(DIRECTION_SOUTH);
}
}
}
if (!keepDistance || offset_x <= 0) {
uint32_t tmpDist = std::max<uint32_t>(std::abs((creaturePos.getX() + 1) - centerPos.getX()), distance_y);
if (tmpDist == centerToDist && canWalkTo(creaturePos, DIRECTION_EAST)) {
bool result = true;
if (keepAttack) {
result = (!canDoAttackNow || canUseAttack(Position(creaturePos.x + 1, creaturePos.y, creaturePos.z), attackedCreature));
}
if (result) {
dirList.push_back(DIRECTION_EAST);
}
}
}
if (!keepDistance || offset_x >= 0) {
uint32_t tmpDist = std::max<uint32_t>(std::abs((creaturePos.getX() - 1) - centerPos.getX()), distance_y);
if (tmpDist == centerToDist && canWalkTo(creaturePos, DIRECTION_WEST)) {
bool result = true;
if (keepAttack) {
result = (!canDoAttackNow || canUseAttack(Position(creaturePos.x - 1, creaturePos.y, creaturePos.z), attackedCreature));
}
if (result) {
dirList.push_back(DIRECTION_WEST);
}
}
}
if (!dirList.empty()) {
std::shuffle(dirList.begin(), dirList.end(), getRandomGenerator());
direction = dirList[uniform_random(0, dirList.size() - 1)];
return true;
}
return false;
}
uint64_t
generateWord64()
{
static std::uniform_int_distribution<uint64_t> distribution;
return distribution(getRandomGenerator());
}
