bool Actor::getNextStep(Direction& dir, uint32_t& flags)
{
if(isIdle || getHealth() <= 0){
//we dont have anyone watching might aswell stop walking
eventWalk = 0;
return false;
}
bool result = false;
if((!followCreature || !hasFollowPath) && !isSummon()){
if(followCreature){
result = getRandomStep(getPosition(), dir);
}else{
if(getTimeSinceLastMove() > 1000){
//choose a random direction
result = getRandomStep(getPosition(), dir);
}
}
}
else if(isSummon() || followCreature){
result = Creature::getNextStep(dir, flags);
if(result){
flags |= FLAG_PATHFINDING;
}
else{
//target dancing
if(attackedCreature && attackedCreature == followCreature){
if(isFleeing()){
result = getDanceStep(getPosition(), dir, false, false);
}
else if(cType.staticAttackChance() < (uint32_t)random_range(1, 100)){
result = getDanceStep(getPosition(), dir);
}
}
}
}
if(result && (canPushItems() || canPushCreatures()) ){
const Position& pos = Combat::getCasterPosition(this, dir);
Tile* tile = g_game.getParentTile(pos.x, pos.y, pos.z);
if(tile){
if(canPushItems()){
pushItems(tile);
}
if(canPushCreatures()){
pushCreatures(tile);
}
}
#ifdef __DEBUG__
else{
std::cout << "getNextStep - no tile." << std::endl;
}
#endif
}
return result;
}
void CandleDataHelper::fillDBData(std::vector<CandleData*> & dataVec, CandleData::CandleTimeType timeType)
{
int cnt = 0;
timeStepVal_ = CandleData::candleTime(timeType);
unsigned long curDate = (*dataVec.begin())->jdate_;
unsigned long curTime = (*dataVec.begin())->startTime_;
std::vector<CandleData*>::iterator iter;
CandleData * curData = *dataVec.begin();
CandleData * prevData = *dataVec.begin();
std::string symbol = curData->symbol_;
for(iter = dataVec.begin(); iter != dataVec.end(); ++iter)
{
curData = (*iter);
unsigned int numMissing = countGap(prevData, curData);
while(curData->jdate_ > curDate ||
(curData->jdate_ == curDate && curData->startTime_ > curTime))
{
CandleData * newData = new CandleData(*prevData);
newData->startTime_ += timeStepVal_;
correctForDayRollover(newData->jdate_, newData->startTime_);
correctForEndOfWeek(newData->jdate_, newData->startTime_);
newData->high_ = getRandomStep(numMissing, prevData->high_, curData->high_);
newData->low_ = getRandomStep(numMissing, prevData->low_, curData->low_);
if(newData->low_ > newData->high_)
{
double temp = newData->low_;
newData->low_ = newData->high_;
newData->high_= temp;
}
newData->close_ = getRandomStep(numMissing, prevData->close_, curData->close_);
newData->open_ = prevData->close_;
newData->candleUpdateType_ = CandleData::MISSING_DATA;
iter = dataVec.insert(iter,newData);
++cnt;
// newCandles.push_back(newData);
// curData = (*iter);
curDate = newData->jdate_;
curTime = newData->startTime_ + timeStepVal_;
prevData = newData;
correctForDayRollover(curDate, curTime);
correctForEndOfWeek(curDate, curTime);
--numMissing;
}
prevData = curData;
curTime += timeStepVal_;
correctForDayRollover(curDate, curTime);
correctForEndOfWeek(curDate, curTime);
}
std::cout << "Total Candles: " << dataVec.size() << " Num added: " << cnt << " Quality: " << 1.0 - (double)cnt/(double)dataVec.size() << std::endl;
ostrm_ << symbol << "," << CandleData::candleTime(timeType) << "," << dataVec.size() << "," << cnt << "," << 1.0 - (double)cnt/(double)dataVec.size() << std::endl;
}
void CandleDataHelper::fillData(std::vector<CandleData*> & dataVec)
{
unsigned long curDate = range_.startJDate_;
unsigned long curTime = range_.startTime_;
std::vector<CandleData*>::iterator iter;
iter = dataVec.begin();
// Trim any front stuff
while((*iter)->jdate_ == curDate && (*iter)->startTime_ < curTime)
{
iter = dataVec.erase(iter);
}
CandleData * curData = *dataVec.begin();
CandleData * prevData = *dataVec.begin();
for(iter = dataVec.begin(); iter != dataVec.end(); ++iter)
{
curData = (*iter);
// data runs past the end of the range
if(curData->jdate_ > range_.endJDate_ ||
(curData->jdate_ == range_.endJDate_ && curData->startTime_ > range_.endTime_))
{
dataVec.erase(iter, dataVec.end());
break;
}
while(curData->jdate_ > curDate ||
(curData->jdate_ == curDate && curData->startTime_ > curTime))
{
CandleData * newData = new CandleData(*prevData);
newData->startTime_ += timeStepVal_;
correctForDayRollover(newData->jdate_, newData->startTime_);
correctForEndOfWeek(newData->jdate_, newData->startTime_);
unsigned int numMissing = countGap(prevData, curData);
newData->high_ = getRandomStep(numMissing, prevData->high_, curData->high_);
newData->low_ = getRandomStep(numMissing, prevData->low_, curData->low_);
if(newData->low_ > newData->high_)
{
double temp = newData->low_;
newData->low_ = newData->high_;
newData->high_= temp;
}
newData->close_ = getRandomStep(numMissing, prevData->close_, curData->close_);
newData->open_ = prevData->close_;
iter = dataVec.insert(iter,newData);
curData = (*iter);
}
prevData = curData;
curTime += timeStepVal_;
correctForDayRollover(curDate, curTime);
correctForEndOfWeek(curDate, curTime);
}
}
void MainWindow::move()
{
auto s_head = getHead();
auto s_food = QPoint(food_pos.x(), food_pos.y());
auto s_foot = getFoot();
state_now = find_way(s_head, s_food);
if(state_now == -1){
state_now = find_way(s_head, s_foot);
}
if(state_now == to_left)
{
go_left();
}else if(state_now == to_right){
go_right();
}else if(state_now == to_up){
go_up();
}else if(state_now == to_down){
go_down();
}else{
state_now = getRandomStep(s_head);
if(state_now == -1){
QMessageBox::information(0, "", "end");
gameover();
}else if(state_now == to_left){
go_left();
}else if(state_now == to_right){
go_right();
}else if(state_now == to_up){
go_up();
}else if(state_now == to_down){
go_down();
}
}
update();
}
bool Npc::getNextStep(Direction& dir)
{
if(Creature::getNextStep(dir)){
return true;
}
if(autoWalkChance > 0 && autoWalkChance >= random_range(1, 100) && focusCreature == 0){
return getRandomStep(dir);
}
return false;
}
bool Monster::getNextStep(Direction& dir, uint32_t& flags)
{
if(isIdle || getHealth() <= 0)
{
//we dont have anyone watching might aswell stop walking
eventWalk = 0;
return false;
}
bool result = false;
if((!followCreature || !hasFollowPath) && !isSummon())
{
if(followCreature || getTimeSinceLastMove() > 1000) //choose a random direction
result = getRandomStep(getPosition(), dir);
}
else if(isSummon() || followCreature)
{
result = Creature::getNextStep(dir, flags);
if(!result)
{
//target dancing
if(attackedCreature && attackedCreature == followCreature)
{
if(isFleeing())
result = getDanceStep(getPosition(), dir, false, false);
else if(mType->staticAttackChance < (uint32_t)random_range(1, 100))
result = getDanceStep(getPosition(), dir);
}
}
else
flags |= FLAG_PATHFINDING;
}
if(result && (canPushItems() || canPushCreatures()))
{
if(Tile* tile = g_game.getTile(Spells::getCasterPosition(this, dir)))
{
if(canPushItems())
pushItems(tile);
if(canPushCreatures())
pushCreatures(tile);
}
#ifdef __DEBUG__
else
std::clog << "[Warning - Monster::getNextStep] no tile found." << std::endl;
#endif
}
return result;
}
bool Monster::getNextStep(Direction& direction, uint32_t& flags)
{
if (isIdle || getHealth() <= 0) {
//we dont have anyone watching might aswell stop walking
eventWalk = 0;
return false;
}
bool result = false;
if ((!followCreature || !hasFollowPath) && (!isSummon() || !isMasterInRange)) {
if (followCreature || getTimeSinceLastMove() > 1000) {
//choose a random direction
result = getRandomStep(getPosition(), direction);
}
} else if ((isSummon() && isMasterInRange) || followCreature) {
result = Creature::getNextStep(direction, flags);
if (result) {
flags |= FLAG_PATHFINDING;
} else {
//target dancing
if (attackedCreature && attackedCreature == followCreature) {
if (isFleeing()) {
result = getDanceStep(getPosition(), direction, false, false);
} else if (mType->info.staticAttackChance < static_cast<uint32_t>(uniform_random(1, 100))) {
result = getDanceStep(getPosition(), direction);
}
}
}
}
if (result && (canPushItems() || canPushCreatures())) {
const Position& pos = Spells::getCasterPosition(this, direction);
Tile* tile = g_game.map.getTile(pos);
if (tile) {
if (canPushItems()) {
Monster::pushItems(tile);
}
if (canPushCreatures()) {
Monster::pushCreatures(tile);
}
}
}
return result;
}
bool Npc::getNextStep(Direction& dir, uint32_t& flags)
{
if (Creature::getNextStep(dir, flags)) {
return true;
}
if (walkTicks <= 0) {
return false;
}
if (focusCreature != 0) {
return false;
}
if (getTimeSinceLastMove() < walkTicks) {
return false;
}
return getRandomStep(dir);
}
bool Npc::getNextStep(Direction& dir)
{
if(Creature::getNextStep(dir)){
return true;
}
if(walkTicks <= 0){
return false;
}
if (hasWalkDelay()) {
return false;
}
if(!isIdle() || focusCreature != 0){
return false;
}
if(getTimeSinceLastMove() < walkTicks){
return false;
}
return getRandomStep(dir);
}
bool Monster::getDistanceStep(const Position& targetPos, Direction& direction, bool flee /* = false */)
{
const Position& creaturePos = getPosition();
int_fast32_t dx = Position::getDistanceX(creaturePos, targetPos);
int_fast32_t dy = Position::getDistanceY(creaturePos, targetPos);
int32_t distance = std::max<int32_t>(dx, dy);
if (!flee && (distance > mType->info.targetDistance || !g_game.isSightClear(creaturePos, targetPos, true))) {
return false; // let the A* calculate it
} else if (!flee && distance == mType->info.targetDistance) {
return true; // we don't really care here, since it's what we wanted to reach (a dancestep will take of dancing in that position)
}
int_fast32_t offsetx = Position::getOffsetX(creaturePos, targetPos);
int_fast32_t offsety = Position::getOffsetY(creaturePos, targetPos);
if (dx <= 1 && dy <= 1) {
//seems like a target is near, it this case we need to slow down our movements (as a monster)
if (stepDuration < 2) {
stepDuration++;
}
} else if (stepDuration > 0) {
stepDuration--;
}
if (offsetx == 0 && offsety == 0) {
return getRandomStep(creaturePos, direction); // player is "on" the monster so let's get some random step and rest will be taken care later.
}
if (dx == dy) {
//player is diagonal to the monster
if (offsetx >= 1 && offsety >= 1) {
// player is NW
//escape to SE, S or E [and some extra]
bool s = canWalkTo(creaturePos, DIRECTION_SOUTH);
bool e = canWalkTo(creaturePos, DIRECTION_EAST);
if (s && e) {
direction = boolean_random() ? DIRECTION_SOUTH : DIRECTION_EAST;
return true;
} else if (s) {
direction = DIRECTION_SOUTH;
return true;
} else if (e) {
direction = DIRECTION_EAST;
return true;
} else if (canWalkTo(creaturePos, DIRECTION_SOUTHEAST)) {
direction = DIRECTION_SOUTHEAST;
return true;
}
/* fleeing */
bool n = canWalkTo(creaturePos, DIRECTION_NORTH);
bool w = canWalkTo(creaturePos, DIRECTION_WEST);
if (flee) {
if (n && w) {
direction = boolean_random() ? DIRECTION_NORTH : DIRECTION_WEST;
return true;
} else if (n) {
direction = DIRECTION_NORTH;
return true;
} else if (w) {
direction = DIRECTION_WEST;
return true;
}
}
/* end of fleeing */
if (w && canWalkTo(creaturePos, DIRECTION_SOUTHWEST)) {
direction = DIRECTION_WEST;
} else if (n && canWalkTo(creaturePos, DIRECTION_NORTHEAST)) {
direction = DIRECTION_NORTH;
}
return true;
} else if (offsetx <= -1 && offsety <= -1) {
//player is SE
//escape to NW , W or N [and some extra]
bool w = canWalkTo(creaturePos, DIRECTION_WEST);
bool n = canWalkTo(creaturePos, DIRECTION_NORTH);
if (w && n) {
direction = boolean_random() ? DIRECTION_WEST : DIRECTION_NORTH;
return true;
} else if (w) {
direction = DIRECTION_WEST;
return true;
} else if (n) {
direction = DIRECTION_NORTH;
return true;
}
if (canWalkTo(creaturePos, DIRECTION_NORTHWEST)) {
direction = DIRECTION_NORTHWEST;
return true;
}
/* fleeing */
bool s = canWalkTo(creaturePos, DIRECTION_SOUTH);
bool e = canWalkTo(creaturePos, DIRECTION_EAST);
if (flee) {
if (s && e) {
direction = boolean_random() ? DIRECTION_SOUTH : DIRECTION_EAST;
return true;
} else if (s) {
direction = DIRECTION_SOUTH;
return true;
} else if (e) {
direction = DIRECTION_EAST;
return true;
}
}
/* end of fleeing */
if (s && canWalkTo(creaturePos, DIRECTION_SOUTHWEST)) {
direction = DIRECTION_SOUTH;
} else if (e && canWalkTo(creaturePos, DIRECTION_NORTHEAST)) {
direction = DIRECTION_EAST;
}
return true;
} else if (offsetx >= 1 && offsety <= -1) {
//player is SW
//escape to NE, N, E [and some extra]
bool n = canWalkTo(creaturePos, DIRECTION_NORTH);
bool e = canWalkTo(creaturePos, DIRECTION_EAST);
if (n && e) {
direction = boolean_random() ? DIRECTION_NORTH : DIRECTION_EAST;
return true;
} else if (n) {
direction = DIRECTION_NORTH;
return true;
} else if (e) {
direction = DIRECTION_EAST;
return true;
}
if (canWalkTo(creaturePos, DIRECTION_NORTHEAST)) {
direction = DIRECTION_NORTHEAST;
return true;
}
/* fleeing */
bool s = canWalkTo(creaturePos, DIRECTION_SOUTH);
bool w = canWalkTo(creaturePos, DIRECTION_WEST);
if (flee) {
if (s && w) {
direction = boolean_random() ? DIRECTION_SOUTH : DIRECTION_WEST;
return true;
} else if (s) {
direction = DIRECTION_SOUTH;
return true;
} else if (w) {
direction = DIRECTION_WEST;
return true;
}
}
/* end of fleeing */
if (w && canWalkTo(creaturePos, DIRECTION_NORTHWEST)) {
direction = DIRECTION_WEST;
} else if (s && canWalkTo(creaturePos, DIRECTION_SOUTHEAST)) {
direction = DIRECTION_SOUTH;
}
return true;
} else if (offsetx <= -1 && offsety >= 1) {
// player is NE
//escape to SW, S, W [and some extra]
bool w = canWalkTo(creaturePos, DIRECTION_WEST);
bool s = canWalkTo(creaturePos, DIRECTION_SOUTH);
if (w && s) {
direction = boolean_random() ? DIRECTION_WEST : DIRECTION_SOUTH;
return true;
} else if (w) {
direction = DIRECTION_WEST;
return true;
} else if (s) {
direction = DIRECTION_SOUTH;
return true;
} else if (canWalkTo(creaturePos, DIRECTION_SOUTHWEST)) {
direction = DIRECTION_SOUTHWEST;
return true;
}
/* fleeing */
bool n = canWalkTo(creaturePos, DIRECTION_NORTH);
bool e = canWalkTo(creaturePos, DIRECTION_EAST);
if (flee) {
if (n && e) {
direction = boolean_random() ? DIRECTION_NORTH : DIRECTION_EAST;
return true;
} else if (n) {
direction = DIRECTION_NORTH;
return true;
} else if (e) {
direction = DIRECTION_EAST;
return true;
}
}
/* end of fleeing */
if (e && canWalkTo(creaturePos, DIRECTION_SOUTHEAST)) {
direction = DIRECTION_EAST;
} else if (n && canWalkTo(creaturePos, DIRECTION_NORTHWEST)) {
direction = DIRECTION_NORTH;
}
return true;
}
}
//Now let's decide where the player is located to the monster (what direction) so we can decide where to escape.
if (dy > dx) {
Direction playerDir = offsety < 0 ? DIRECTION_SOUTH : DIRECTION_NORTH;
switch (playerDir) {
case DIRECTION_NORTH: {
// Player is to the NORTH, so obviously we need to check if we can go SOUTH, if not then let's choose WEST or EAST and again if we can't we need to decide about some diagonal movements.
if (canWalkTo(creaturePos, DIRECTION_SOUTH)) {
direction = DIRECTION_SOUTH;
return true;
}
bool w = canWalkTo(creaturePos, DIRECTION_WEST);
bool e = canWalkTo(creaturePos, DIRECTION_EAST);
if (w && e && offsetx == 0) {
direction = boolean_random() ? DIRECTION_WEST : DIRECTION_EAST;
return true;
} else if (w && offsetx <= 0) {
direction = DIRECTION_WEST;
return true;
} else if (e && offsetx >= 0) {
direction = DIRECTION_EAST;
return true;
}
/* fleeing */
if (flee) {
if (w && e) {
direction = boolean_random() ? DIRECTION_WEST : DIRECTION_EAST;
return true;
} else if (w) {
direction = DIRECTION_WEST;
return true;
} else if (e) {
direction = DIRECTION_EAST;
return true;
}
}
/* end of fleeing */
bool sw = canWalkTo(creaturePos, DIRECTION_SOUTHWEST);
bool se = canWalkTo(creaturePos, DIRECTION_SOUTHEAST);
if (sw || se) {
// we can move both dirs
if (sw && se) {
direction = boolean_random() ? DIRECTION_SOUTHWEST : DIRECTION_SOUTHEAST;
} else if (w) {
direction = DIRECTION_WEST;
} else if (sw) {
direction = DIRECTION_SOUTHWEST;
} else if (e) {
direction = DIRECTION_EAST;
} else if (se) {
direction = DIRECTION_SOUTHEAST;
}
return true;
}
/* fleeing */
if (flee && canWalkTo(creaturePos, DIRECTION_NORTH)) {
// towards player, yea
direction = DIRECTION_NORTH;
return true;
}
/* end of fleeing */
break;
}
case DIRECTION_SOUTH: {
if (canWalkTo(creaturePos, DIRECTION_NORTH)) {
direction = DIRECTION_NORTH;
return true;
}
bool w = canWalkTo(creaturePos, DIRECTION_WEST);
bool e = canWalkTo(creaturePos, DIRECTION_EAST);
if (w && e && offsetx == 0) {
direction = boolean_random() ? DIRECTION_WEST : DIRECTION_EAST;
return true;
} else if (w && offsetx <= 0) {
direction = DIRECTION_WEST;
return true;
} else if (e && offsetx >= 0) {
direction = DIRECTION_EAST;
return true;
}
/* fleeing */
if (flee) {
if (w && e) {
direction = boolean_random() ? DIRECTION_WEST : DIRECTION_EAST;
return true;
} else if (w) {
direction = DIRECTION_WEST;
return true;
} else if (e) {
direction = DIRECTION_EAST;
return true;
}
}
/* end of fleeing */
bool nw = canWalkTo(creaturePos, DIRECTION_NORTHWEST);
bool ne = canWalkTo(creaturePos, DIRECTION_NORTHEAST);
if (nw || ne) {
// we can move both dirs
if (nw && ne) {
direction = boolean_random() ? DIRECTION_NORTHWEST : DIRECTION_NORTHEAST;
} else if (w) {
direction = DIRECTION_WEST;
} else if (nw) {
direction = DIRECTION_NORTHWEST;
} else if (e) {
direction = DIRECTION_EAST;
} else if (ne) {
direction = DIRECTION_NORTHEAST;
}
return true;
}
/* fleeing */
if (flee && canWalkTo(creaturePos, DIRECTION_SOUTH)) {
// towards player, yea
direction = DIRECTION_SOUTH;
return true;
}
/* end of fleeing */
break;
}
default:
break;
}
} else {
Direction playerDir = offsetx < 0 ? DIRECTION_EAST : DIRECTION_WEST;
switch (playerDir) {
case DIRECTION_WEST: {
if (canWalkTo(creaturePos, DIRECTION_EAST)) {
direction = DIRECTION_EAST;
return true;
}
bool n = canWalkTo(creaturePos, DIRECTION_NORTH);
bool s = canWalkTo(creaturePos, DIRECTION_SOUTH);
if (n && s && offsety == 0) {
direction = boolean_random() ? DIRECTION_NORTH : DIRECTION_SOUTH;
return true;
} else if (n && offsety <= 0) {
direction = DIRECTION_NORTH;
return true;
} else if (s && offsety >= 0) {
direction = DIRECTION_SOUTH;
return true;
}
/* fleeing */
if (flee) {
if (n && s) {
direction = boolean_random() ? DIRECTION_NORTH : DIRECTION_SOUTH;
return true;
} else if (n) {
direction = DIRECTION_NORTH;
return true;
} else if (s) {
direction = DIRECTION_SOUTH;
return true;
}
}
/* end of fleeing */
bool se = canWalkTo(creaturePos, DIRECTION_SOUTHEAST);
bool ne = canWalkTo(creaturePos, DIRECTION_NORTHEAST);
if (se || ne) {
if (se && ne) {
direction = boolean_random() ? DIRECTION_SOUTHEAST : DIRECTION_NORTHEAST;
} else if (s) {
direction = DIRECTION_SOUTH;
} else if (se) {
direction = DIRECTION_SOUTHEAST;
} else if (n) {
direction = DIRECTION_NORTH;
} else if (ne) {
direction = DIRECTION_NORTHEAST;
}
return true;
}
/* fleeing */
if (flee && canWalkTo(creaturePos, DIRECTION_WEST)) {
// towards player, yea
direction = DIRECTION_WEST;
return true;
}
/* end of fleeing */
break;
}
case DIRECTION_EAST: {
if (canWalkTo(creaturePos, DIRECTION_WEST)) {
direction = DIRECTION_WEST;
return true;
}
bool n = canWalkTo(creaturePos, DIRECTION_NORTH);
bool s = canWalkTo(creaturePos, DIRECTION_SOUTH);
if (n && s && offsety == 0) {
direction = boolean_random() ? DIRECTION_NORTH : DIRECTION_SOUTH;
return true;
} else if (n && offsety <= 0) {
direction = DIRECTION_NORTH;
return true;
} else if (s && offsety >= 0) {
direction = DIRECTION_SOUTH;
return true;
}
/* fleeing */
if (flee) {
if (n && s) {
direction = boolean_random() ? DIRECTION_NORTH : DIRECTION_SOUTH;
return true;
} else if (n) {
direction = DIRECTION_NORTH;
return true;
} else if (s) {
direction = DIRECTION_SOUTH;
return true;
}
}
/* end of fleeing */
bool nw = canWalkTo(creaturePos, DIRECTION_NORTHWEST);
bool sw = canWalkTo(creaturePos, DIRECTION_SOUTHWEST);
if (nw || sw) {
if (nw && sw) {
direction = boolean_random() ? DIRECTION_NORTHWEST : DIRECTION_SOUTHWEST;
} else if (n) {
direction = DIRECTION_NORTH;
} else if (nw) {
direction = DIRECTION_NORTHWEST;
} else if (s) {
direction = DIRECTION_SOUTH;
} else if (sw) {
direction = DIRECTION_SOUTHWEST;
}
return true;
}
/* fleeing */
if (flee && canWalkTo(creaturePos, DIRECTION_EAST)) {
// towards player, yea
direction = DIRECTION_EAST;
return true;
}
/* end of fleeing */
break;
}
default:
break;
}
}
return true;
}
