//==============================================================================
void GameServer::tick()
{
/*float dt = (time_.elapsed() - lastTime_) * 0.001f;*/
lastTime_ = time_.elapsed();
/*if (actors_.size() < 100 && !testingStageActive_)
{
GenMonsters_();
}*/
auto collideWithGrid = [=](Actor* actor, EActorDirection direction)
{
auto& p = *actor;
float x = p.GetPosition().x;
float y = p.GetPosition().y;
bool collided = false;
if ((levelMap_.GetCell(x + 0.49f, y - 0.51f) != '.'
|| levelMap_.GetCell(x + 0.49f, y + 0.49f) != '.')
&& levelMap_.GetCell(x - slideThreshold_+ 0.5f, y) == '.'
&& (direction == EActorDirection::NORTH
|| direction == EActorDirection::SOUTH))
{
p.SetPosition(Vector2(x - slideThreshold_+ 0.0001f, p.GetPosition().y));
}
if (levelMap_.GetCell(x + slideThreshold_- 0.5f, y) == '.'
&&((levelMap_.GetCell(x - 0.5f, y - 0.51f) != '.'
|| levelMap_.GetCell(x - 0.5f, y + 0.49f) != '.')
&& (direction == EActorDirection::NORTH
|| direction == EActorDirection::SOUTH)))
{
p.SetPosition(Vector2(x + slideThreshold_- 0.0001f, p.GetPosition().y));
}
if (levelMap_.GetCell(x, y - slideThreshold_ + 0.5f) == '.'
&& (levelMap_.GetCell(x - 0.51f, y + 0.49f) != '.'
|| levelMap_.GetCell(x + 0.49f, y + 0.49f) != '.')
&& (direction == EActorDirection::EAST
|| direction == EActorDirection::WEST))
{
p.SetPosition(Vector2(p.GetPosition().x, y - slideThreshold_+ 0.0001f));
}
if ((levelMap_.GetCell(x + 0.49f, y - 0.5f) != '.'
|| levelMap_.GetCell(x - 0.51f, y - 0.5f) != '.')
&& levelMap_.GetCell(x, y + slideThreshold_- 0.5f) == '.'
&& (direction == EActorDirection::EAST
|| direction == EActorDirection::WEST))
{
p.SetPosition(Vector2(p.GetPosition().x, y + slideThreshold_ - 0.001f));
}
if (levelMap_.GetCell(x + 0.5f, y) != '.')
{
p.SetPosition(Vector2(round(x + 0.5f) - 0.5f, p.GetPosition().y));
collided = true;
}
if (levelMap_.GetCell(x - 0.51f, y) != '.')
{
p.SetPosition(Vector2(round(x - 0.5f) + 0.5f, p.GetPosition().y));
collided = true;
}
if (levelMap_.GetCell(x, y + 0.5f) != '.')
{
p.SetPosition(Vector2(p.GetPosition().x, round(y + 0.5f) - 0.5f));
collided = true;
}
if (levelMap_.GetCell(x, y - 0.51f) != '.')
{
p.SetPosition(Vector2(p.GetPosition().x, round(y - 0.5f) + 0.5f));
collided = true;
}
if (collided)
{
actor->OnCollideWorld();
}
};
for (Actor* actor: actors_)
{
if (actor->GetType() == EActorType::MONSTER)
{
Monster* monster = dynamic_cast<Monster*>(actor);
Creature* target = monster->target;
float distance2;
Vector2 m_pos = actor->GetPosition();
if (target && target != nullptr)
{
Vector2 t_pos = target->GetPosition();
distance2 = Sqr(m_pos.x - t_pos.x)
+ Sqr(m_pos.y - t_pos.y);
if (distance2 < 25)
{
if (abs(m_pos.x - t_pos.x - 1.0f) < playerVelocity_
&& m_pos.x - t_pos.x - 1.0f != 0)
{
monster->SetPosition(Vector2(t_pos.x + 1.0f, m_pos.y));
monster->SetDirection(EActorDirection::NONE);
}
if (abs(m_pos.y - t_pos.y + 1.0f) < playerVelocity_
&& m_pos.y - t_pos.y + 1.0f != 0)
{
monster->SetPosition(Vector2(m_pos.x, t_pos.y - 1.0f));
monster->SetDirection(EActorDirection::NONE);
}
if (m_pos.x < t_pos.x - 1.0f)
{
monster->SetDirection(EActorDirection::EAST);
}
else if (m_pos.x > t_pos.x + 1.0f)
{
monster->SetDirection(EActorDirection::WEST);
}
else if (m_pos.y < t_pos.y - 1.0f)
{
monster->SetDirection(EActorDirection::SOUTH);
}
else if (m_pos.y > t_pos.y + 1.0f)
{
monster->SetDirection(EActorDirection::NORTH);
}
}
}
if (!target
|| target == nullptr
|| distance2 >= 5)
{
for (Actor* tar : actors_)
{
if (tar != monster)
{
bool b = false;
if (tar->GetType() != EActorType::ITEM
&& tar->GetType () != EActorType::PROJECTILE)
{
Creature* m = dynamic_cast<Creature*>(tar);
QStringList str = monster->Flags.filter("HATE");
for (QString hate: str)
{
if (Hates[hate] == m->GetRace())
{
b = true;
break;
}
}
if (b)
{
Vector2 t_pos = tar->GetPosition();
distance2 = Sqr(m_pos.x - t_pos.x) + Sqr(m_pos.y - t_pos.y);
// Dasha told 5^2 is a protocol defined const
if (distance2 < 25)
{
monster->target = m;
break;
}
}
}
}
}
}
}
if (actor->GetType() == EActorType::MONSTER
|| actor->GetType() == EActorType::PLAYER)
{
Creature* monster = dynamic_cast<Creature*>(actor);
if (monster->GetHealth() <= 0)
{
KillActor_(actor);
break;
}
}
}
for (Actor* actor: actors_)
{
if (!actor
|| actor == nullptr)
{
break;
}
auto v = directionToVector[static_cast<unsigned>(actor->GetDirection())] ;
actor->SetVelocity(v);
float dt = playerVelocity_;
Vector2 old_pos = actor->GetPosition();
Vector2 new_pos = old_pos + v * (dt + 0.001);
Vector2 old_pos2 = old_pos + v * 0.51;
levelMap_.RemoveActor(actor);
EActorDirection d = actor->GetDirection();
float x = new_pos.x;
float y = new_pos.y;
if (levelMap_.GetCell(old_pos2.x, old_pos2.y) != '#'
&& d != EActorDirection::NONE
&& (((levelMap_.GetCell(x - slideThreshold_+ 0.5f, y) == '.'
&& levelMap_.GetCell(x + slideThreshold_- 0.5f, y) == '.')
&& (d == EActorDirection::NORTH
|| d == EActorDirection::SOUTH))
|| ((levelMap_.GetCell(x, y - slideThreshold_+ 0.5f) == '.'
&& levelMap_.GetCell(x, y + slideThreshold_- 0.5f) == '.')
&& (d == EActorDirection::EAST
|| d == EActorDirection::WEST))))
{
if (levelMap_.GetCell(new_pos.x, new_pos.y) == '.')
{
if (!actor->Update(dt)
&& actor->GetType () == EActorType::PROJECTILE)
{
static_cast<Projectile*>(actor)->death = true;
}
collideWithGrid(actor, d);
}
else if (levelMap_.GetCell(x , y) != '.'
&& playerVelocity_ >= 1)
{
bool b = false;
for (float i = 0.01; i <= dt; i += 0.01)
{
new_pos = old_pos + v * i + v * 0.5f;
if (levelMap_.GetCell(new_pos.x, new_pos.y) == '#' && !b)
{
actor->Update(i - 0.01);
b = true;
}
}
}
else
{
if (actor->GetType () == EActorType::PROJECTILE)
{
static_cast<Projectile*>(actor)->death = true;
}
}
}
else
{
if (actor
&& actor != nullptr)
{
if (actor->GetType () == EActorType::PROJECTILE)
{
static_cast<Projectile*>(actor)->death = true;
}
else
{
actor->OnCollideWorld();
}
}
}
if (actor->GetType() == EActorType::PLAYER)
{
Player* player = dynamic_cast<Player*>(actor);
if (player->GetHealth() < player->GetMaxHealth())
{
player->SetHealth(player->GetHealth() + 1);
}
}
if (actor->GetType() == EActorType::MONSTER)
{
Monster* monster = dynamic_cast<Monster*>(actor);
Creature* target = monster->target;
if (target && target->GetHealth() > 0)
{
Vector2 m_pos = actor->GetPosition();
Vector2 t_pos = target->GetPosition();
float distance2 = Sqr(m_pos.x - t_pos.x)
+ Sqr(m_pos.y - t_pos.y);
if (distance2 <= Sqr(pickUpRadius_))
{
events_ << monster->atack(target);
events_ << target->atack(monster);
}
}
}
for (Actor* neighbour : actors_)
{
if (actor == nullptr
|| neighbour == nullptr
|| actor == neighbour
|| neighbour->GetType() == EActorType::ITEM
|| (actor->GetType() == EActorType::PROJECTILE
&& neighbour->GetType() == EActorType::PROJECTILE))
{
break;
}
Box box0(neighbour->GetPosition(), 0.9f, 0.9f);
Box box1(actor->GetPosition(), 0.9f, 0.9f);
if (box0.Intersect(box1))
{
actor->OnCollideActor(neighbour);
neighbour->OnCollideActor(actor);
if (actor->GetType() == EActorType::PROJECTILE)
{
static_cast<Projectile*>(actor)->death = true;
if (neighbour->GetType () == EActorType::MONSTER)
{
Monster* monster = dynamic_cast<Monster*>(neighbour);
if (monster->GetHealth () <= 0)
{
GetItems(monster);
}
}
}
else if (neighbour->GetType() == EActorType::PROJECTILE)
{
static_cast<Projectile*>(neighbour)->death = true;
if (actor->GetType() == EActorType::MONSTER)
{
Monster* monster = dynamic_cast<Monster*>(actor);
if (monster->GetHealth () <= 0)
{
GetItems(monster);
}
}
}
else if (neighbour->GetType() != EActorType::ITEM)
{
actor->SetPosition(old_pos);
}
}
}
if (actor->GetType() == EActorType::PROJECTILE
&& static_cast<Projectile*>(actor)->death)
{
QVariantMap ans1;
ans1["radius"] = 1.0f;
ans1["x"] = actor->GetPosition ().x;
ans1["y"] = actor->GetPosition ().y;
QVariantMap ans;
ans["explode"] = ans1;
events_ << ans;
idToActor_.erase(actor->GetId());
actors_.erase(std::remove(actors_.begin(), actors_.end(), actor), actors_.end());
delete actor;
actor = nullptr;
}
else
{
levelMap_.IndexActor(actor);
}
}
QVariantMap tickMessage;
tickMessage["tick"] = tick_;
tickMessage["events"] = events_;
events_.clear();
emit broadcastMessage(QString(QJsonDocument::fromVariant(tickMessage).toJson()));
tick_++;
}
//==============================================================================
void GameServer::HandlePutMob_(const QVariantMap& request, QVariantMap& response)
{
if (!testingStageActive_)
{
WriteResult_(response, EFEMPResult::BAD_ACTION);
return;
}
if (!request["x"].toFloat()
|| !request["y"].toFloat())
{
WriteResult_(response, EFEMPResult::BAD_PLACING);
return;
}
float x = request["x"].toFloat();
float y = request["y"].toFloat();
Monster* monster = CreateActor_<Monster>();
SetActorPosition_(monster, Vector2(x, y));
monster->SetDirection(EActorDirection::SOUTH);
if (IsPositionWrong(x, y, monster))
{
KillActor_(monster);
WriteResult_(response, EFEMPResult::BAD_PLACING);
return;
}
auto flags = request["flags"].toList();
for (auto flag: flags)
{
if (monster->possibleFlags.lastIndexOf(flag.toString()) == -1)
{
WriteResult_(response, EFEMPResult::BAD_FLAG);
return;
}
monster->Flags.push_back(flag.toString());
}
monster->SetRace(request["race"].toString());
if (monster->GetRace() == "NONE")
{
WriteResult_(response, EFEMPResult::BAD_RACE);
return;
}
auto stats = request["stats"].toMap();
for (auto s = stats.begin(); s != stats.end(); s++)
{
EStatConst stat = StringToStat[s.key()];
QVariant val = s.value();
monster->SetStat(stat, val.toFloat());
}
auto inventory = request["inventory"].toList();
for (auto elem: inventory)
{
Item* item = CreateActor_<Item>();
SetItemDescription(elem.toMap(), item);
item->SetOnTheGround(false);
monster->items.push_back(item);
actors_.erase(std::remove(actors_.begin(), actors_.end(), item)
, actors_.end()); //???
}
QStringList damage;
damage << request["dealtDamage"].toString().split("d");
if (damage.size() < 2
|| !damage[0].toInt()
|| !damage[1].toInt())
{
WriteResult_(response, EFEMPResult::BAD_DAMAGE);
return;
}
response["id"] = monster->GetId();
}