bool ChatHandler::HandleAppearCommand(const char* args, WorldSession *m_session)
{
if(!*args)
return false;
Player *slf = m_session->GetPlayer();
if(!slf) return true;
Player *chr = objmgr.GetPlayer(args, false);
if (chr && ( chr->m_isGmInvisible != INVIS_ADMIN || slf->RS_getAccess() == RS_ADMIN ) )
{
char buf[256];
if( chr->IsBeingTeleported() )
{
snprintf((char*)buf,256, "%s is already being teleported.", chr->GetName());
SystemMessage(m_session, buf);
return true;
}
MapInfo * pMI = chr->GetMapMgr()->GetMapInfo();
if(pMI && pMI->required_access > slf->RS_getAccess())
{
snprintf((char*)buf,256, "You do not have the required access level to go to this location.");
SystemMessage(m_session, buf);
return true;
}
if(chr->m_isGmInvisible && !slf->m_isGmInvisible)
{
SystemMessage(m_session, "Target unit is using GM Invis,");
SystemMessage(m_session, "You need to turn on GM Invis to port to this player");
return true;
}
snprintf((char*)buf,256, "Appearing at %s's location.", chr->GetName()); // -- europa
SystemMessage(m_session, buf);
if( slf->m_isGmInvisible == INVIS_NONE )
{
char buf0[256];
snprintf((char*)buf0,256, "%s is appearing to your location.", slf->GetName());
SystemMessageToPlr(chr, buf0);
}
//m_session->GetPlayer()->SafeTeleport(chr->GetMapId(), chr->GetInstanceID(), chr->GetPosition());
//If the GM is on the same map as the player, use the normal safeteleport method
if ( slf->GetMapId() == chr->GetMapId() && m_session->GetPlayer()->GetInstanceID() == chr->GetInstanceID() )
slf->SafeTeleport(chr->GetMapId(),chr->GetInstanceID(),chr->GetPosition());
else
slf->SafeTeleport(chr->GetMapMgr(), chr->GetPosition());
//The player and GM are not on the same map. We use this method so we can port to BG's (Above method doesn't support them)
}
else
{
char buf[256];
snprintf((char*)buf,256, "Player (%s) does not exist or is not logged in.", args);
SystemMessage(m_session, buf);
}
return true;
}
void Player::SpinAndMove(Player& Player1, Player& Player2, int (&Board) [10][10])
{
int spinner = 0, newpos = 0;
cout << endl;
SetConsoleTextAttribute(console, 12);
cout << Player1.GetName();
cout << " you spun a ";
spinner = 1 + (rand() % 6);
cout << spinner << endl;
cout << Player1.GetName();
cout << " new position after spin: ";
newpos = Player1.GetPosition() + spinner;
Player1.SetPosition(newpos);
cout << Player1.GetPosition() << endl;
CheckChutes(newpos);
Player1.SetPosition(newpos);
CheckLadders(newpos);
Player1.SetPosition(newpos);
Player1.DisplayNewMove(Board, Player1);
cout << "Please press enter to continue...";
cin.get();
system("cls");
SetConsoleTextAttribute(console, 9);
cout << endl;
cout << Player2.GetName();
cout << " you spun a ";
spinner = 1 + (rand() % 6);
cout << spinner << endl;
cout << Player2.GetName();
cout << " new position after spin: ";
newpos = Player2.GetPosition() + spinner;
Player2.SetPosition(newpos);
cout << Player2.GetPosition() << endl;
CheckChutes(newpos);
Player2.SetPosition(newpos);
CheckLadders(newpos);
Player2.SetPosition(newpos);
Player2.DisplayNewMove(Board, Player2);
cout << "Please press enter to continue...";
cin.get();
system("cls");
}
void PlayerCamera::Initialise( int minZoom, int maxZoom, int screenWidth, int screenHeight,
Player& player)
{
Camera::Initialise(minZoom, maxZoom, screenWidth, screenHeight);
m_posX = player.GetPosition().x;
m_posY = player.GetPosition().y;
}
//! returns true if reached by the player
bool ConfigPoint::IsReached()
{
Player* pPlayer = Player::Instance();
PlayerCamera* pPlayerCamera = PlayerCamera::Instance();
Vector3 vPlayerBasePos = pPlayer->GetPosition();
const Matrix44& transform = GetTransformationMatrix();
f32 fDeltaPos = -1.0f;
if(pPlayer->GetBaseSpeed().Y > 0.0f)
{
fDeltaPos = vPlayerBasePos.Y - transform.GetTranslation().Y;
}
else
{
if(pPlayer->GetBaseSpeed().X > 0.0f)
{
fDeltaPos = vPlayerBasePos.X - transform.GetTranslation().X;
}
else
{
fDeltaPos = transform.GetTranslation().X - vPlayerBasePos.X;
}
}
return (fDeltaPos > 0.0f);
}
//==============================================================================
void GameServer::HandleDrop_(const QVariantMap& request, QVariantMap& response)
{
int id = request["id"].toInt();
if (!id)
{
WriteResult_(response, EFEMPResult::BAD_ID);
return;
}
auto sid = request["sid"].toByteArray();
Player* p = sidToPlayer_[sid];
if (p->DropItemFromSlot(id))
{
WriteResult_(response, EFEMPResult::OK);
return;
}
for (auto& item: p->items_)
{
if (item->GetId() == id)
{
//idToActor_[item->GetId()] = item;
actors_.push_back(item);
item->SetPosition(p->GetPosition());
levelMap_.IndexActor(item);
item->SetOnTheGround(true);
p->items_.erase(std::remove(p->items_.begin(), p->items_.end(), item)
, p->items_.end());
WriteResult_(response, EFEMPResult::OK);
return;
}
}
WriteResult_(response, EFEMPResult::BAD_ID);
}
bool ChatHandler::HandleSummonCommand(const char* args, WorldSession *m_session)
{
if (!*args)
return false;
sGMLog.writefromsession(m_session, "summoned %s on map %u, %f %f %f", args, m_session->GetPlayer()->GetMapId(), m_session->GetPlayer()->GetPositionX(), m_session->GetPlayer()->GetPositionY(), m_session->GetPlayer()->GetPositionZ());
Player *chr = objmgr.GetPlayer(args, false);
if (chr)
{
// send message to user
char buf[256];
char buf0[256];
if (chr->IsBeingTeleported() == true)
{
snprintf((char*)buf, 256, "%s is already being teleported.", chr->GetName());
SystemMessage(m_session, buf);
return true;
}
snprintf((char*)buf, 256, "You are summoning %s.", chr->GetName());
SystemMessage(m_session, buf);
if (!m_session->GetPlayer()->m_isGmInvisible)
{
// send message to player
snprintf((char*)buf0, 256, "You are being summoned by %s.", m_session->GetPlayer()->GetName());
SystemMessageToPlr(chr, buf0);
}
Player * plr = m_session->GetPlayer();
if (plr->GetMapMgr() == chr->GetMapMgr())
chr->_Relocate(plr->GetMapId(), plr->GetPosition(), false, false, plr->GetInstanceID());
else
{
sEventMgr.AddEvent(chr, &Player::EventPortToGM, plr, 0, 1, 1, 0);
}
}
else
{
PlayerInfo * pinfo = objmgr.GetPlayerInfoByName(args);
if (!pinfo)
{
char buf[256];
snprintf((char*)buf, 256, "Player (%s) does not exist.", args);
SystemMessage(m_session, buf);
}
else
{
Player * pPlayer = m_session->GetPlayer();
char query[512];
snprintf((char*)&query, 512, "UPDATE characters SET mapId = %u, positionX = %f, positionY = %f, positionZ = %f, zoneId = %u WHERE guid = %u;", pPlayer->GetMapId(), pPlayer->GetPositionX(), pPlayer->GetPositionY(), pPlayer->GetPositionZ(), pPlayer->GetZoneId(), pinfo->guid);
CharacterDatabase.Execute(query);
char buf[256];
snprintf((char*)buf, 256, "(Offline) %s has been summoned.", pinfo->name);
SystemMessage(m_session, buf);
}
}
return true;
}
static bool HandleMmapPathCommand(ChatHandler* handler, char const* args)
{
if (!MMAP::MMapFactory::createOrGetMMapManager()->GetNavMesh(handler->GetSession()->GetPlayer()->GetMapId(), handler->GetSession()->GetPlayer()->GetTerrainSwaps()))
{
handler->PSendSysMessage("NavMesh not loaded for current map.");
return true;
}
handler->PSendSysMessage("mmap path:");
// units
Player* player = handler->GetSession()->GetPlayer();
Unit* target = handler->getSelectedUnit();
if (!player || !target)
{
handler->PSendSysMessage("Invalid target/source selection.");
return true;
}
char* para = strtok((char*)args, " ");
bool useStraightPath = false;
if (para && strcmp(para, "true") == 0)
useStraightPath = true;
bool useStraightLine = false;
if (para && strcmp(para, "line") == 0)
useStraightLine = true;
// unit locations
float x, y, z;
player->GetPosition(x, y, z);
// path
PathGenerator path(target);
path.SetUseStraightPath(useStraightPath);
bool result = path.CalculatePath(x, y, z, false, useStraightLine);
Movement::PointsArray const& pointPath = path.GetPath();
handler->PSendSysMessage("%s's path to %s:", target->GetName().c_str(), player->GetName().c_str());
handler->PSendSysMessage("Building: %s", useStraightPath ? "StraightPath" : useStraightLine ? "Raycast" : "SmoothPath");
handler->PSendSysMessage("Result: %s - Length: %zu - Type: %u", (result ? "true" : "false"), pointPath.size(), path.GetPathType());
G3D::Vector3 const &start = path.GetStartPosition();
G3D::Vector3 const &end = path.GetEndPosition();
G3D::Vector3 const &actualEnd = path.GetActualEndPosition();
handler->PSendSysMessage("StartPosition (%.3f, %.3f, %.3f)", start.x, start.y, start.z);
handler->PSendSysMessage("EndPosition (%.3f, %.3f, %.3f)", end.x, end.y, end.z);
handler->PSendSysMessage("ActualEndPosition (%.3f, %.3f, %.3f)", actualEnd.x, actualEnd.y, actualEnd.z);
if (!player->IsGameMaster())
handler->PSendSysMessage("Enable GM mode to see the path points.");
for (uint32 i = 0; i < pointPath.size(); ++i)
player->SummonCreature(VISUAL_WAYPOINT, pointPath[i].x, pointPath[i].y, pointPath[i].z, 0, TEMPSUMMON_TIMED_DESPAWN, 9000);
return true;
}
void Shielder::Update()
{
fixed s = _power ? M_PT_ZERO_ONE * 12 : M_PT_ZERO_ONE * 4;
Rotate( s );
GetShape( 9 ).Rotate( -2 * s );
for ( int i = 0; i < 8; i++ )
GetShape( i ).Rotate( -s );
bool onScreen = false;
if ( GetPosition()._x < 0 )
_dir.Set( 1, 0 );
else if ( GetPosition()._x > Lib::WIDTH )
_dir.Set( -1, 0 );
else if ( GetPosition()._y < 0 )
_dir.Set( 0, 1 );
else if ( GetPosition()._y > Lib::HEIGHT )
_dir.Set( 0, -1 );
else
onScreen = true;
if ( !onScreen && _rotate ) {
_timer = 0;
_rotate = false;
}
fixed speed = SPEED + ( _power ? M_PT_ONE * 3 : M_PT_ONE * 2 ) * ( 16 - GetHP() );
if ( _rotate ) {
Vec2 d( _dir );
d.Rotate( ( _rDir ? 1 : -1 ) * ( TIMER - _timer ) * M_PI / ( M_TWO * TIMER ) );
_timer--;
if ( _timer <= 0 ) {
_timer = 0;
_rotate = false;
_dir.Rotate( ( _rDir ? 1 : -1 ) * M_PI / M_TWO );
}
Move( d * speed );
}
else {
_timer++;
if ( _timer > TIMER * 2 ) {
_timer = TIMER;
_rotate = true;
_rDir = GetLib().RandInt( 2 ) != 0;
}
if ( IsOnScreen() && _timer % TIMER == TIMER / 2 && _power ) {
Player* p = GetNearestPlayer();
Vec2 v = GetPosition();
Vec2 d = p->GetPosition() - v;
d.Normalise();
Spawn( new SBBossShot( v, d * M_THREE, 0x33cc99ff ) );
PlaySoundRandom( Lib::SOUND_BOSS_FIRE );
}
Move( _dir * speed );
}
_dir.Normalise();
}
void PlayerCamera::Update( float dt, Player& player, Input& input, Level& level )
{
int newPosX = 0,
newPosY = 0;
//if(input.GetMouseButtonState(4))
//{
// m_zoomLevel += 1;
//}
//if(input.GetMouseButtonState(5))
//{
// m_zoomLevel -= 1;
//}
// Sets the camera to always be in the center of the screen where the player is
newPosX = player.GetPosition().x - (m_screenWidth / 2) +
((player.GetWidth() / 2) * (player.GetScale() * m_zoomLevel));
newPosY = player.GetPosition().y - (m_screenHeight / 2) +
((player.GetHeight() / 2) * (player.GetScale() * m_zoomLevel));
m_posX = Lerp(m_posX, newPosX, 0.07f);
m_posY = Lerp(m_posY, newPosY, 0.07f);
//Restrict to the level
if(m_posX >= (level.GetMapSize()*32) - (m_screenWidth))
{
m_posX = (level.GetMapSize()*32) - (m_screenWidth);
}
if(m_posX <= 0)
{
m_posX = 0;
}
if(m_posY >= (level.GetMapSize()*32) - (m_screenHeight))
{
m_posY = (level.GetMapSize()*32) - (m_screenHeight);
}
if(m_posY <= 0)
{
m_posY = 0;
}
Camera::Update(dt);
}
static bool HandleMmapPathCommand(ChatHandler* handler, const char* args)
{
if (!MMAP::MMapFactory::createOrGetMMapManager()->GetNavMesh(handler->GetSession()->GetPlayer()->GetMapId()))
{
handler->PSendSysMessage("NavMesh not loaded for current map.");
return true;
}
handler->PSendSysMessage("mmap path:");
// units
Player* player = handler->GetSession()->GetPlayer();
Unit* target = handler->getSelectedUnit();
if (!player || !target)
{
handler->PSendSysMessage("Invalid target/source selection.");
return true;
}
char* para = strtok((char*)args, " ");
bool useStraightPath = false;
if (para && strcmp(para, "true") == 0)
useStraightPath = true;
// unit locations
float x, y, z;
player->GetPosition(x, y, z);
// path
PathInfo path(target, x, y, z, useStraightPath);
PointPath pointPath = path.getFullPath();
handler->PSendSysMessage("%s's path to %s:", target->GetName(), player->GetName());
handler->PSendSysMessage("Building %s", useStraightPath ? "StraightPath" : "SmoothPath");
handler->PSendSysMessage("length %i type %u", pointPath.size(), path.getPathType());
PathNode start = path.getStartPosition();
PathNode next = path.getNextPosition();
PathNode end = path.getEndPosition();
PathNode actualEnd = path.getActualEndPosition();
handler->PSendSysMessage("start (%.3f, %.3f, %.3f)", start.x, start.y, start.z);
handler->PSendSysMessage("next (%.3f, %.3f, %.3f)", next.x, next.y, next.z);
handler->PSendSysMessage("end (%.3f, %.3f, %.3f)", end.x, end.y, end.z);
handler->PSendSysMessage("actual end (%.3f, %.3f, %.3f)", actualEnd.x, actualEnd.y, actualEnd.z);
if (!player->isGameMaster())
handler->PSendSysMessage("Enable GM mode to see the path points.");
// this entry visible only to GM's with "gm on"
static const uint32 WAYPOINT_NPC_ENTRY = 1;
for (uint32 i = 0; i < pointPath.size(); ++i)
player->SummonCreature(WAYPOINT_NPC_ENTRY, pointPath[i].x, pointPath[i].y, pointPath[i].z, 0, TEMPSUMMON_TIMED_DESPAWN, 9000);
return true;
}
Player::Player(const Player& p)
{
m_State = p.GetState();
m_Lvl = p.GetLvl();
m_Id = p.GetId();
m_TeamName = p.GetTeamName();
m_Orientation = p.GetOrientation();
m_Coo = p.GetPosition();
m_Inventory = p.GetInventory();
}
static bool HandleMmapLocCommand(ChatHandler* handler, const char* /*args*/)
{
handler->PSendSysMessage("mmap tileloc:");
// grid tile location
Player* player = handler->GetSession()->GetPlayer();
int32 gx = 32 - player->GetPositionX() / SIZE_OF_GRIDS;
int32 gy = 32 - player->GetPositionY() / SIZE_OF_GRIDS;
handler->PSendSysMessage("%03u%02i%02i.mmtile", player->GetMapId(), gy, gx);
handler->PSendSysMessage("gridloc [%i,%i]", gx, gy);
// calculate navmesh tile location
const dtNavMesh* navmesh = MMAP::MMapFactory::createOrGetMMapManager()->GetNavMesh(player->GetMapId());
const dtNavMeshQuery* navmeshquery = MMAP::MMapFactory::createOrGetMMapManager()->GetNavMeshQuery(player->GetMapId(), player->GetInstanceId());
if (!navmesh || !navmeshquery)
{
handler->PSendSysMessage("NavMesh not loaded for current map.");
return true;
}
const float* min = navmesh->getParams()->orig;
float x, y, z;
player->GetPosition(x, y, z);
float location[VERTEX_SIZE] = {y, z, x};
float extents[VERTEX_SIZE] = {2.f,4.f,2.f};
int32 tilex = int32((y - min[0]) / SIZE_OF_GRIDS);
int32 tiley = int32((x - min[2]) / SIZE_OF_GRIDS);
handler->PSendSysMessage("Calc [%02i,%02i]", tilex, tiley);
// navmesh poly -> navmesh tile location
dtQueryFilter filter = dtQueryFilter();
dtPolyRef polyRef = INVALID_POLYREF;
navmeshquery->findNearestPoly(location, extents, &filter, &polyRef, NULL);
if (polyRef == INVALID_POLYREF)
handler->PSendSysMessage("Dt [??,??] (invalid poly, probably no tile loaded)");
else
{
const dtMeshTile* tile;
const dtPoly* poly;
navmesh->getTileAndPolyByRef(polyRef, &tile, &poly);
if (tile)
handler->PSendSysMessage("Dt [%02i,%02i]", tile->header->x, tile->header->y);
else
handler->PSendSysMessage("Dt [??,??] (no tile loaded)");
}
return true;
}
/**
Déplacement d'un Player dans la map
**/
void PlayState::movePlayer(Player &player){
float movHor=0;
float movVer=0;
int limitVer=0;
int limitHor=0;
float movHorTest=player.GetVelx()*m_gameEngine->m_app.GetFrameTime()/1000.f;
float movVerTest=player.GetVely()*m_gameEngine->m_app.GetFrameTime()/1000.f;
bool bas=false, haut=false, gauche=false, droite=false, kill=false;
//! On vérifie les collisions horizontals
if(!player.CollisionHorizontal(player.GetMovedPlayerRect(movHorTest,0),gauche,droite,limitHor)){//! Pas de collision
movHor=movHorTest;
}
else{//! Sinon on reposition le joueur
player.SetVelx(0);
if(gauche)movHor=((((limitHor+1)*GameConfig::g_config["tilewidth"]))-player.GetPosition().x)/1000.f;
if(droite)movHor=((((limitHor)*GameConfig::g_config["tilewidth"]))-GameConfig::g_config["playercollwidth"]-player.GetPosition().x)/1000.f;
}
//! On vérifie les collisions vertical
if(!player.CollisionVertical(player.GetMovedPlayerRect(0,movVerTest),haut,bas,limitVer)){//! Pas de collision
player.Gravity(m_gameEngine->m_app);
movVer=movVerTest;
}
else{//! Sinon on reposition le joueur
if(haut){//! Si l'on touche le haut
player.SetVely(0);
}
if(bas){//! Si l'on touche le sol
if(!player.GetBottomCollision())movVer=(player.GetPosition().y-(limitVer*GameConfig::g_config["tileheight"])+GameConfig::g_config["playercollheight"])/1000.f;
player.UnlockJump();
player.SetBottomCollision(true);
}
}
//! On vérifie si le mouvement envisagé cause une collision
if(!player.CollisionGeneral(player.GetMovedPlayerRect(movHor,movVer),kill)&&movHor<GameConfig::g_config["tileheight"]&&movVer<GameConfig::g_config["tilewidth"])player.Move(movHor,movVer);
else player.SetVely(0);
//! Ouch!
if(kill)player.Degat(200);
}
bool ChatHandler::HandleAppearCommand(const char* args, WorldSession *m_session)
{
if(!*args)
return false;
Player *chr = objmgr.GetPlayer(args, false);
if (chr)
{
char buf[256];
if( chr->IsBeingTeleported() ) {
snprintf((char*)buf,256, "%s is already being teleported.", chr->GetName());
SystemMessage(m_session, buf);
return true;
}
snprintf((char*)buf,256, "Appearing at %s's location.", chr->GetName()); // -- europa
SystemMessage(m_session, buf);
if(!m_session->GetPlayer()->m_isGmInvisible)
{
char buf0[256];
snprintf((char*)buf0,256, "%s is appearing to your location.", m_session->GetPlayer()->GetName());
SystemMessageToPlr(chr, buf0);
}
//m_session->GetPlayer()->SafeTeleport(chr->GetMapId(), chr->GetInstanceID(), chr->GetPosition());
//If the GM is on the same map as the player, use the normal safeteleport method
if ( m_session->GetPlayer()->GetMapId() == chr->GetMapId() && m_session->GetPlayer()->GetInstanceID() == chr->GetInstanceID() )
m_session->GetPlayer()->SafeTeleport(chr->GetMapId(),chr->GetInstanceID(),chr->GetPosition());
else
m_session->GetPlayer()->SafeTeleport(chr->GetMapMgr(), chr->GetPosition());
//The player and GM are not on the same map. We use this method so we can port to BG's (Above method doesn't support them)
}
else
{
char buf[256];
snprintf((char*)buf,256, "Player (%s) does not exist or is not logged in.", args);
SystemMessage(m_session, buf);
}
return true;
}
static bool HandleWpGetCommand(ChatHandler* handler, const char* args)
{
if (!*args)
return false;
float x,y,z;
Player* Pl = handler->GetSession()->GetPlayer();
Pl->GetPosition(x,y,z);
sLog->outString("AddWaypoint(, %ff, %ff, %ff);",x,y,z);
Pl->SummonGameObject(188650, x, y, z,0,0,0,0,0,0);
return false;
}
static bool HandleWpGetCommand(ChatHandler* handler, const char* args)
{
if (!*args)
return false;
float x,y,z;
Player* Pl = handler->GetSession()->GetPlayer();
Pl->GetPosition(x,y,z);
TC_LOG_INFO(LOG_FILTER_GENERAL, "AddWaypoint(, %ff, %ff, %ff);",x,y,z);
Pl->SummonGameObject(188650, x, y, z,0,0,0,0,0,0);
return false;
}
//==============================================================================
void GameServer::HandleDestroyItem_(const QVariantMap& request, QVariantMap& response)
{
#define BAD_ID(COND)\
if (COND)\
{\
WriteResult_(response, EFEMPResult::BAD_ID);\
return;\
}\
BAD_ID(request.find("id") == request.end());
int id = request["id"].toInt();
BAD_ID(!id);
Player* p = sidToPlayer_[request["sid"].toByteArray()];
if (p->DropItemFromSlot(id))
{
//destroy item from slot
WriteResult_(response, EFEMPResult::OK);
return;
}
if (p->GetItemId(id))
{
//destroy item from inventory
for (auto& item : p->items_)
{
if (item->GetId() == id)
{
p->items_.erase(std::remove(p->items_.begin(), p->items_.end(), item), p->items_.end());
idToActor_.erase(id);
break;
}
}
}
else
{
//item is on the ground
Item* item = dynamic_cast<Item*>(idToActor_[id]);
BAD_ID(!item || !item->GetOnTheGround());
Vector2 player_pos = p->GetPosition();
Vector2 item_pos = item->GetPosition();
float distance2 = Sqr(player_pos.x - item_pos.x)
+ Sqr(player_pos.y - item_pos.y);
BAD_ID(distance2 > Sqr(pickUpRadius_))
KillActor_(item);
}
// TODO: implement
#undef BAD_ID
}
//==============================================================================
void GameServer::HandleUseSkill_(const QVariantMap& request, QVariantMap& response)
{
auto sid = request["sid"].toByteArray();
Player* p = sidToPlayer_[sid];
float x = request["x"].toFloat();
float y = request["y"].toFloat();
if (!x || !y)
{
WriteResult_(response, EFEMPResult::BAD_PLACING);
return;
}
Projectile* project = CreateActor_<Projectile>();
project->SetPosition (Vector2(p->GetPosition().x, p->GetPosition().y));
project->SetPoint(Vector2(x, y));
project->SetPlayer(p);
project->GetCoord ();
project->SetDirection (EActorDirection::EAST);
levelMap_.IndexActor(project);
WriteResult_(response, EFEMPResult::OK);
return;
}
static bool HandleMassSummonCommand(ChatHandler* handler, char const* args)
{
Player* target = handler->GetSession()->GetPlayer();
uint64 guid = target->GetGUID();
float x, y, z;
target->GetPosition(x, y, z);
uint32 mapId = target->GetMapId();
uint32 zone = target->GetZoneId();
float orient = target->GetOrientation();
uint32 phase = target->GetPhaseMask();
//handler->GetSession()->GetPlayer()->GetClosePoint(x, y, z, target->GetObjectSize());
//target->TeleportTo(handler->GetSession()->GetPlayer()->GetMapId(), x, y, z, target->GetOrientation());
//target->SetPhaseMask(handler->GetSession()->GetPlayer()->GetPhaseMask(), true);
sWorld->MassSummon(guid, mapId, x, y, z, zone, orient, phase);
return true;
}
//==============================================================================
void GameServer::HandlePickUp_(const QVariantMap& request, QVariantMap& response)
{
auto sid = request["sid"].toByteArray();
Player* player = sidToPlayer_[sid];
int id = request["id"].toInt();
Item* item = dynamic_cast<Item*>(idToActor_[id]);
if (!id
|| !item
|| !item->GetOnTheGround())
{
WriteResult_(response, EFEMPResult::BAD_ID);
return;
}
int totalWeight = player->GetTotalWeigh();
float carryingCapacity = player->GetCarryingSapacity();
int weight = item->GetWeight();
if (totalWeight + weight >= carryingCapacity)
{
WriteResult_(response, EFEMPResult::TOO_HEAVY);
return;
}
Vector2 player_pos = player->GetPosition();
Vector2 item_pos = item->GetPosition();
float distance2 = Sqr(player_pos.x - item_pos.x)
+ Sqr(player_pos.y - item_pos.y);
if (distance2 > Sqr(pickUpRadius_))
{
WriteResult_(response, EFEMPResult::BAD_ID);
return;
}
item->SetOnTheGround(false);
levelMap_.RemoveActor(item);
actors_.erase(std::remove(actors_.begin(), actors_.end(), item), actors_.end());
//idToActor_.erase(id);
player->items_.push_back(dynamic_cast<Item*>(item));
}
void NpcValkyrShadowguardAI::calcPathToDropPoint()
{
pathVector.clear();
Player* pPlayer = ObjectAccessor::GetPlayer(*me, grabbedPlayer);
if (!pPlayer)
{
me->DespawnOrUnsummon();
return;
}
Position currentPos, dropPos;
pPlayer->GetPosition(¤tPos);
float orientation = 0.0f;
if (Creature* pCreature = sObjectAccessor->GetCreature(*me, dropPointTriggerGUID))
{
pCreature->GetPosition(&dropPos);
pathSteps = float(me->GetDistance2d(pCreature));
orientation = me->GetAngle(&dropPos);
}
else
{
me->DespawnOrUnsummon();
return;
}
float posXdiff = ((dropPos.GetPositionX() - currentPos.GetPositionX()) / (float)pathSteps);
float posYdiff = ((dropPos.GetPositionY() - currentPos.GetPositionY()) / (float)pathSteps);
for (uint8 i = 1; i <= (pathSteps - 5); ++i) // Stop 5 points (yd) before trigger
{
Position pointPos;
pointPos.m_positionX = ((posXdiff * i) + currentPos.m_positionX);
pointPos.m_positionY = ((posYdiff * i) + currentPos.m_positionY);
pointPos.m_positionZ = (currentPos.m_positionZ + 1.5f);
pointPos.m_orientation = orientation;
pathVector.push_back(pointPos);
}
}
void Player::DisplayNewMove(int (&Board) [10][10], Player Player1)
{
// search through array and find Player's position..
for ( int i=0; i < 10; i++)
{
for (int j=0; j <10; j++)
{
cout << setw(4) << Board[i][j] << " ";
if ( Player1.GetPosition() == Board[i][j])
{
cout << Player1.GetPiece();
}
}
cout << endl;
cout << "-----" << "-----" << "-----" << "-----" << "-----" << "-----" << "-----" << "-----" << "-----" << "-----" << endl;
cout << "| |" << "| |"<< "| |" << "| |" << "| |" << "| |" << "| |" << "| |" << "| |" << "| |" << endl;
cout << "| |" << "| |"<< "| |" << "| |" << "| |" << "| |" << "| |" << "| |" << "| |" << "| |" << endl;
cout << "-----" << "-----" << "-----" << "-----" << "-----" << "-----" << "-----" << "-----" << "-----" << "-----" << endl;
}
}
void CommandHandler::HandleTeleportToCommand()
{
std::string PlayerName;
ExtractArg(PlayerName);
Player* pTargetPlayer = ObjectAccessor::GetInstance()->FindPlayer(PlayerName);
if (pTargetPlayer)
{
if (pTargetPlayer->IsInWorld())
{
pPlayer->Teleport((Map*)pTargetPlayer->GetContainer(), pTargetPlayer->GetPosition());
}
else
{
pPlayer->SendCommandReponse("Player is not in world !");
}
}
else
{
pPlayer->SendCommandReponse("Player doesn't exist !");
}
}
void CommandHandler::HandleTeleportToCommand()
{
std::string PlayerName;
ExtractArg(PlayerName);
Player* pTargetPlayer = sObjectMgr.GetPlayer(PlayerName);
if (pTargetPlayer)
{
if (pTargetPlayer->IsInWorld())
{
pPlayer->Teleport(pTargetPlayer->GetPosition());
}
else
{
pPlayer->SendCommandReponse("Player is not in world !");
}
}
else
{
pPlayer->SendCommandReponse("Player doesn't exist !");
}
}
bool Player::CouldGoPosition(Point position)
{
for( int x = (position.x - mRadius)/64; x <= (position.x + mRadius)/64; x += 1 )//64 = tilesize
{
for( int y = (position.y - mRadius)/64; y <= (position.y + mRadius)/64; y += 1 )//64 = tilesize
{
if ( GGameMap->isValidTile(Point(x*64,y*64)) == false)
return false;
}
}
std::map<int,Player*> players = GPlayerManager->GetPlayers();
for( std::map<int,Player*>::iterator it = players.begin(); it != players.end(); ++it )
{
Player* enemy = it->second;
if(enemy == this)continue;
if( Point().GetDistance( enemy->GetPosition(), position ) < mRadius*2 )
{
return false;
}
}
return true;
}
void UpdateAI(const uint32 diff)
{
if (EventInProgress) {
Player* pWarrior = NULL;
if (PlayerGUID)
pWarrior = Unit::GetPlayer(*me, PlayerGUID);
if (!pWarrior)
return;
if (!pWarrior->isAlive() && pWarrior->GetQuestStatus(1719) == QUEST_STATUS_INCOMPLETE) {
EventInProgress = false;
DoScriptText(SAY_TWIGGY_FLATHEAD_DOWN, me);
pWarrior->FailQuest(1719);
for (uint8 i = 0; i < 6; ++i)
{
if (AffrayChallenger[i])
{
Creature* pCreature = Unit::GetCreature((*me), AffrayChallenger[i]);
if (pCreature) {
if (pCreature->isAlive())
{
pCreature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IN_COMBAT);
pCreature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
pCreature->setDeathState(JUST_DIED);
}
}
}
AffrayChallenger[i] = 0;
Challenger_down[i] = false;
}
if (BigWill)
{
Creature* pCreature = Unit::GetCreature((*me), BigWill);
if (pCreature) {
if (pCreature->isAlive()) {
pCreature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_IN_COMBAT);
pCreature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
pCreature->setDeathState(JUST_DIED);
}
}
}
BigWill = 0;
}
if (!EventGrate && EventInProgress)
{
float x, y, z;
pWarrior->GetPosition(x, y, z);
if (x >= -1684 && x <= -1674 && y >= -4334 && y <= -4324) {
pWarrior->AreaExploredOrEventHappens(1719);
DoScriptText(SAY_TWIGGY_FLATHEAD_BEGIN, me);
for (uint8 i = 0; i < 6; ++i)
{
Creature* pCreature = me->SummonCreature(NPC_AFFRAY_CHALLENGER, AffrayChallengerLoc[i][0], AffrayChallengerLoc[i][1], AffrayChallengerLoc[i][2], AffrayChallengerLoc[i][3], TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, 600000);
if (!pCreature)
continue;
pCreature->setFaction(35);
pCreature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
pCreature->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
pCreature->HandleEmoteCommand(EMOTE_ONESHOT_ROAR);
AffrayChallenger[i] = pCreature->GetGUID();
}
Wave_Timer = 5000;
Challenger_checker = 1000;
EventGrate = true;
}
}
else if (EventInProgress)
{
if (Challenger_checker <= diff)
{
for (uint8 i = 0; i < 6; ++i)
{
if (AffrayChallenger[i])
{
Creature* pCreature = Unit::GetCreature((*me), AffrayChallenger[i]);
if ((!pCreature || (!pCreature->isAlive())) && !Challenger_down[i])
{
DoScriptText(SAY_TWIGGY_FLATHEAD_DOWN, me);
Challenger_down[i] = true;
}
}
}
Challenger_checker = 1000;
} else Challenger_checker -= diff;
if (Wave_Timer <= diff)
{
if (AffrayChallenger[Wave] && Wave < 6 && !EventBigWill)
{
DoScriptText(SAY_TWIGGY_FLATHEAD_FRAY, me);
Creature* pCreature = Unit::GetCreature((*me), AffrayChallenger[Wave]);
if (pCreature && (pCreature->isAlive()))
{
pCreature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
pCreature->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
pCreature->HandleEmoteCommand(EMOTE_ONESHOT_ROAR);
pCreature->setFaction(14);
pCreature->AI()->AttackStart(pWarrior);
++Wave;
Wave_Timer = 20000;
}
}
else if (Wave >= 6 && !EventBigWill) {
if (Creature* pCreature = me->SummonCreature(NPC_BIG_WILL, -1722, -4341, 6.12f, 6.26f, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, 480000))
{
BigWill = pCreature->GetGUID();
//pCreature->GetMotionMaster()->MovePoint(0, -1693, -4343, 4.32f);
//pCreature->GetMotionMaster()->MovePoint(1, -1684, -4333, 2.78f);
pCreature->GetMotionMaster()->MovePoint(2, -1682, -4329, 2.79f);
pCreature->HandleEmoteCommand(EMOTE_STATE_READYUNARMED);
EventBigWill = true;
Wave_Timer = 1000;
}
}
else if (Wave >= 6 && EventBigWill && BigWill)
{
Creature* pCreature = Unit::GetCreature((*me), BigWill);
if (!pCreature || !pCreature->isAlive())
{
DoScriptText(SAY_TWIGGY_FLATHEAD_OVER, me);
EventInProgress = false;
EventBigWill = false;
EventGrate = false;
PlayerGUID = 0;
Wave = 0;
}
}
} else Wave_Timer -= diff;
}
}
}
void ClusterInterface::HandlePlayerTeleport(WorldPacket & pck)
{
//result has to be 2 here
uint8 result, method;
uint32 sessionid, mapid, instanceid;
LocationVector location;
uint32 sessionid2;
pck >> result >> method;
//someones messing with something
if (result != 2)
return;
pck >> sessionid >> mapid >> instanceid >> location >> sessionid2;
//we need to get sessionid2!
WorldSession* s = GetSession(sessionid2);
if (s == NULL)
return;
//if method is 0, simply teleport us to the location provided :)
if (method == 0)
sEventMgr.AddEvent(s->GetPlayer(), &Player::EventSafeTeleport, mapid, instanceid, location, EVENT_UNK, 1, 1, EVENT_FLAG_DO_NOT_EXECUTE_IN_WORLD_CONTEXT);
else
{
Player* p = s->GetPlayer();
if (p == NULL)
return; //wtf
//change the method for 0, and fill it reversely, so the player is teleported to us :)
//result has to be 2 when sending back here, so it relays it to the original players server
WorldPacket data(ICMSG_PLAYER_TELEPORT);
data << uint8(2) << uint8(0) << sessionid2 << p->GetMapId() << p->GetInstanceID() << p->GetPosition() << sessionid;
}
}
//==============================================================================
void GameServer::HandleLook_(const QVariantMap& request, QVariantMap& response)
{
auto sid = request["sid"].toByteArray();
Player* p = sidToPlayer_[sid];
QVariantList rows;
auto pos = p->GetPosition();
response["x"] = pos.x;
response["y"] = pos.y;
int x = GridRound(pos.x);
int y = GridRound(pos.y);
int xDelta = (screenColumnCount_ - 1) / 2;
int yDelta = (screenRowCount_ - 1) / 2;
int minX = x - xDelta;
int maxX = x + xDelta;
int minY = y - yDelta;
int maxY = y + yDelta;
QVariantList actors;
std::unordered_set<Actor*> actorsInArea;
for (int j = minY; j <= maxY; j++)
{
QVariantList row;
for (int i = minX; i <= maxX; i++)
{
row.push_back(QString(levelMap_.GetCell(i, j)));
auto& actorsInCell = levelMap_.GetActors(i, j);
for (auto& a: actorsInCell)
{
actorsInArea.insert(a);
}
}
rows.push_back(row);
}
for (auto& a : actorsInArea)
{
QVariantMap actor;
actor["type"] = TypeToString[a->GetType()];
actor["x"] = a->GetPosition().x;
actor["y"] = a->GetPosition().y;
actor["id"] = a->GetId();
if (actor["type"] == "monster")
{
auto m = dynamic_cast<Monster*>(a);
actor["mobType"] = m->GetName();
}
if (actor["type"] != "item"
&& actor["type"] != "projectile")
{
auto m = dynamic_cast<Creature*>(a);
actor["health"] = m->GetHealth();
actor["maxHealth"] = m->GetMaxHealth();
actor["race"] = m->GetRace();
}
if (actor["type"] == "item")
{
actor["name"] = dynamic_cast<Item*>(a)->Getname();
}
if (actor["type"] == "projectile")
{
actor["name"] = "fireball_projectile";
}
if (actor["health"] <= 0
&& (actor["type"] == "monster"))
{
Creature* b = dynamic_cast<Creature*>(a);
idToActor_.erase(b->GetId());
levelMap_.RemoveActor(b);
actors_.erase(std::remove(actors_.begin(), actors_.end(), b), actors_.end());
delete b;
b = nullptr;
}
if (actor["type"] == "projectile"
|| actor["type"] == "item"
|| actor["health"] > 0)
{
actors << actor;
}
}
response["map"] = rows;
response["actors"] = actors;
}
//==============================================================================
void GameServer::HandleEquip_(const QVariantMap& request, QVariantMap& response)
{
#define BAD_ID(COND)\
if (COND)\
{\
WriteResult_(response, EFEMPResult::BAD_ID);\
return;\
}\
BAD_ID(request.find("id") == request.end());
BAD_ID(!request["id"].toInt());
QString slot = request["slot"].toString();
if (SlotToString.find(slot) == SlotToString.end())
{
WriteResult_(response, EFEMPResult::BAD_SLOT);
return;
}
int id = request["id"].toInt();
auto sid = request["sid"].toByteArray();
Player* p = sidToPlayer_[sid];
BAD_ID((idToActor_.find(id) == idToActor_.end()) && !p->GetItemId(id));
if (p->GetItemId(id))
{
//equip item from inventory
for (auto& item: p->items_)
{
if (item->GetId() == id)
{
Item* i = p->GetSlot(SlotToString[slot]);
if (i)
{
p->items_.push_back(i);
}
if (!p->SetSlot(SlotToString[slot], item))
{
WriteResult_(response, EFEMPResult::BAD_SLOT);
return;
}
p->SetStat(true, item);
p->items_.erase(std::remove(p->items_.begin(), p->items_.end(), item), p->items_.end());
WriteResult_(response, EFEMPResult::OK);
return;
}
}
BAD_ID(true);
}
else
{
//item is on the ground
Item* item = dynamic_cast<Item*>(idToActor_[id]);
BAD_ID(!item);
Vector2 player_pos = p->GetPosition();
Vector2 item_pos = item->GetPosition();
float distance2 = Sqr(player_pos.x - item_pos.x) + Sqr(player_pos.y - item_pos.y);
BAD_ID(distance2 > Sqr(pickUpRadius_))
if (!p->SetSlot(SlotToString[slot], item))
{
WriteResult_(response, EFEMPResult::BAD_SLOT);
return;
}
p->SetStat(true, item);
//KillActor_(item); ???
idToActor_.erase(item->GetId());
actors_.erase(std::remove(actors_.begin(), actors_.end(), item), actors_.end());
}
#undef BAD_ID
}
//==============================================================================
void GameServer::HandleUse_(const QVariantMap& request, QVariantMap& response)
{
auto sid = request["sid"].toByteArray();
Player* p = sidToPlayer_[sid];
if (!request["id"].toInt())
{
WriteResult_(response, EFEMPResult::BAD_ID);
return;
}
int id = request["id"].toInt();
Item* item = dynamic_cast<Item*>(idToActor_[request["id"].toInt()]);
if (item)
{
if (request.find("x") == request.end() && request.find("y") == request.end())
{
if (item->GetSubtype() != "consumable")
{
WriteResult_(response, EFEMPResult::BAD_ID);
return;
}
else
{
p->SetHealth(p->GetHealth() + item->bonuses[EStatConst::HP]["value"].toFloat());
WriteResult_(response, EFEMPResult::OK);
return;
}
}
if ((item != p->GetSlot(left_hand)
|| item != p->GetSlot(right_hand))
&& (p->GetSlot(left_hand) != 0
|| p->GetSlot(right_hand)!= 0 )
&& id != FistId_)
{
WriteResult_(response, EFEMPResult::BAD_SLOT);
return;
}
WriteResult_ (response, EFEMPResult::OK);
return;
}
if (!request["x"].toFloat() || !request["y"].toFloat())
{
WriteResult_(response, EFEMPResult::BAD_PLACING);
return;
}
for (Actor* actor : actors_)
{
if (actor->GetType() != EActorType::ITEM
&& actor->GetType() != EActorType::PROJECTILE)
{
Creature* target = static_cast<Creature*>(actor);
if ((p->GetId() != target->GetId())
&& (target->GetHealth() > 0))
{
Vector2 player_pos = p->GetPosition();
Vector2 target_pos = target->GetPosition();
float distance2 = Sqr(player_pos.x - target_pos.x)
+ Sqr(player_pos.y - target_pos.y);
if (distance2 <= Sqr(pickUpRadius_))
{
QVariantMap a = p->atack(target, id);
events_ << a;
if (target->GetHealth() <= 0)
{
GetItems(target);
p->SetExperience(p->GetExperience () + 300);
int lev = p->GetLevel();
p->SetLevel (p->GetExperience() / 1000);
if (lev < p->GetLevel())
{
p->AddStat ();
p->UpdateStat();
}
}
else
{
a = target->atack(p);
events_ << a;
}
WriteResult_(response, EFEMPResult::OK);
return;
}
}
}
}
}
