void NPC::StopWandering()
{ // stops a mob from wandering, takes him off grid and sends him back to spawn point
roamer=false;
CastToNPC()->SetGrid(0);
SendPosition();
mlog(QUESTS__PATHING, "Stop Wandering requested.");
return;
}
void NPC::StopWandering()
{ // stops a mob from wandering, takes him off grid and sends him back to spawn point
roamer=false;
CastToNPC()->SetGrid(0);
SendPosition();
Log.Out(Logs::Detail, Logs::Pathing, "Stop Wandering requested.");
return;
}
void NPC::NextGuardPosition() {
if (!CalculateNewPosition2(guard_x, guard_y, guard_z, GetMovespeed())) {
SetHeading(guard_heading);
mlog(AI__WAYPOINTS, "Unable to move to next guard position. Probably rooted.");
}
else if((x_pos == guard_x) && (y_pos == guard_y) && (z_pos == guard_z))
{
if(moved)
{
moved=false;
SetMoving(false);
SendPosition();
}
}
}
int main( int argc, char **argv )
{
#undef atoi
if( argc < 2 )
{
printf( "%s {S|H|M} \n"
" S - show\n"
" H - hide\n"
" M - requires 4 additional parameters < x y width height >\n", argv[0] );
return 0;
}
else if( argv[1][0] == 'S' || argv[1][0] == 's' )
SendShow();
else if( argv[1][0] == 'H' || argv[1][0] == 'h' )
SendHide();
else if( argv[1][0] == 'M' || argv[1][0] == 'm' )
SendPosition( atoi( argv[2] ), atoi( argv[3] ), atoi( argv[4] ), atoi( argv[5] ) );
WakeableSleep( 250 );
return 0;
}
void NPC::PauseWandering(int pausetime)
{ // causes wandering to stop but is resumable
// 0 pausetime means pause until resumed
// otherwise automatically resume when time is up
if (GetGrid() != 0)
{
DistractedFromGrid = true;
Log.Out(Logs::Detail, Logs::Pathing, "Paused Wandering requested. Grid %d. Resuming in %d ms (0=not until told)", GetGrid(), pausetime);
SendPosition();
if (pausetime<1)
{ // negative grid number stops him dead in his tracks until ResumeWandering()
SetGrid( 0 - GetGrid());
}
else
{ // specified waiting time, he'll resume after that
AIwalking_timer->Start(pausetime*1000); // set the timer
}
} else {
Log.Out(Logs::General, Logs::Error, "NPC not on grid - can't pause wandering: %lu", (unsigned long)GetNPCTypeID());
}
return;
}
void Object::SendObject(Player *player)
{
//first send the create info
SendCreateInfo(player);
//send Object Effects (if any)
SendObjectEffects(player);
//send Relationship
SendRelationship(player);
//Send Position
SendPosition(player);
//Send Auxdata
SendAuxDataPacket(player);
//Send Navigation
SendNavigation(player);
OnCreate(player);
}
bool Engine::Network::CNetworkEngine::Update()
{
if (m_bHost)
{
Engine::CActor* pcPlayer = m_pcWorld->GetActorByName("PlayerCube");
float fNewLocationX = pcPlayer->GetMetricMember("LocationX");
float fNewLocationY = pcPlayer->GetMetricMember("LocationY");
float fNewLocationZ = pcPlayer->GetMetricMember("LocationZ");
SendPosition(fNewLocationX, fNewLocationY, fNewLocationZ);
float fNewRotationX = pcPlayer->GetMetricMember("RotationX");
float fNewRotationY = pcPlayer->GetMetricMember("RotationY");
float fNewRotationZ = pcPlayer->GetMetricMember("RotationZ");
SendRotation(fNewRotationX, fNewRotationY, fNewRotationZ);
//Engine::CActor* pcScoreZone1 = m_pcWorld->GetActorByName("ScoreZone1");
//float fScore = pcScoreZone1->GetMetricMember("Score");
//SendScore(fScore);
float fStamina = pcPlayer->GetMetricMember("Stamina");
SendStamina(fStamina);
float fWalk = pcPlayer->GetMetricMember("SoundWalk");
float fSurface = pcPlayer->GetMetricMember("LastHitSurface");
SendSoundWalk(fWalk == 0.0f ? false : true, fSurface);
float fSprint = pcPlayer->GetMetricMember("SoundSprint");
SendSoundSprint(fSprint == 0.0f ? false : true);
}
else
{
Engine::CActor* pcPlayer2 = m_pcWorld->GetActorByName("PlayerCube2");
float fNewLocationX = pcPlayer2->GetMetricMember("LocationX");
float fNewLocationY = pcPlayer2->GetMetricMember("LocationY");
float fNewLocationZ = pcPlayer2->GetMetricMember("LocationZ");
SendPosition(fNewLocationX, fNewLocationY, fNewLocationZ);
float fNewRotationX = pcPlayer2->GetMetricMember("RotationX");
float fNewRotationY = pcPlayer2->GetMetricMember("RotationY");
float fNewRotationZ = pcPlayer2->GetMetricMember("RotationZ");
SendRotation(fNewRotationX, fNewRotationY, fNewRotationZ);
//Engine::CActor* pcScoreZone2 = m_pcWorld->GetActorByName("ScoreZone2");
//float fScore = pcScoreZone2->GetMetricMember("Score");
//SendScore(fScore);
float fStamina = pcPlayer2->GetMetricMember("Stamina");
SendStamina(fStamina);
float fWalk = pcPlayer2->GetMetricMember("SoundWalk");
float fSurface = pcPlayer2->GetMetricMember("LastHitSurface");
SendSoundWalk(fWalk == 0.0f ? false : true, fSurface);
float fSprint = pcPlayer2->GetMetricMember("SoundSprint");
SendSoundSprint(fSprint == 0.0f ? false : true);
}
for (m_pcPacket = m_pcPeer->Receive(); m_pcPacket; m_pcPeer->DeallocatePacket(m_pcPacket), m_pcPacket = m_pcPeer->Receive())
{
switch (m_pcPacket->data[0])
{
case ID_REMOTE_DISCONNECTION_NOTIFICATION:
DEBUGPRINT("Another client has disconnected.\n");
m_bConnected = false;
break;
case ID_REMOTE_CONNECTION_LOST:
DEBUGPRINT("Another client has lost the connection.\n");
break;
case ID_REMOTE_NEW_INCOMING_CONNECTION:
DEBUGPRINT("Another client has connected.\n");
m_bConnected = true;
break;
case ID_CONNECTION_REQUEST_ACCEPTED:
{
DEBUGPRINT("Our connection request has been accepted.\n");
m_bConnected = true;
// Use a BitStream to write a custom user message
// Bitstreams are easier to use than sending casted structures, and handle endian swapping automatically
RakNet::BitStream bsOut;
bsOut.Write((RakNet::MessageID)ID_GAME_VERSION);
bsOut.Write(m_sztVersionNumber);
m_pcPeer->Send(&bsOut, HIGH_PRIORITY, RELIABLE_ORDERED, 0, m_pcPacket->systemAddress, false);
}
break;
case ID_NEW_INCOMING_CONNECTION:
DEBUGPRINT("A connection is incoming.\n");
m_bConnected = true;
break;
case ID_NO_FREE_INCOMING_CONNECTIONS:
DEBUGPRINT("The server is full.\n");
break;
case ID_DISCONNECTION_NOTIFICATION:
if (m_bHost)
{
DEBUGPRINT("A client has disconnected.\n");
}
else
{
DEBUGPRINT("We have been disconnected.\n");
}
m_bConnected = false;
break;
case ID_CONNECTION_LOST:
if (m_bHost)
{
DEBUGPRINT("A client lost the connection.\n");
}
else
{
DEBUGPRINT("Connection lost.\n");
}
break;
case ID_GAME_VERSION:
{
memcpy(m_pcSystemAddress, &(m_pcPacket->systemAddress), sizeof(RakNet::SystemAddress));
size_t sztVersion = 0;
RakNet::BitStream bsIn(m_pcPacket->data, m_pcPacket->length, false);
bsIn.IgnoreBytes(sizeof(RakNet::MessageID));
bsIn.Read(sztVersion);
if (m_sztVersionNumber != sztVersion)
{
if (m_bHost)
{
DEBUGPRINT("Server is using version %i. Client had version %i. Disconnecting client.\n", m_sztVersionNumber, sztVersion);
}
else
{
DEBUGPRINT("Connected to server with matching version of %u\n", sztVersion);
}
m_pcPeer->CloseConnection(RakNet::AddressOrGUID(m_pcPacket), true);
}
else
{
if (m_bHost)
{
DEBUGPRINT("Client connected to server with matching version of %u\n", m_sztVersionNumber);
RakNet::BitStream bsOut;
bsOut.Write((RakNet::MessageID)ID_GAME_VERSION);
bsOut.Write(m_sztVersionNumber);
m_pcPeer->Send(&bsOut, HIGH_PRIORITY, RELIABLE_ORDERED, 0, m_pcPacket->systemAddress, false);
}
else
{
DEBUGPRINT("Connected to server with matching version %i.\n", m_sztVersionNumber);
size_t sztNetworkID = 1;
RakNet::BitStream bsOut;
bsOut.Write((RakNet::MessageID)ID_GAME_SETUP);
bsOut.Write(sztNetworkID);
m_pcPeer->Send(&bsOut, HIGH_PRIORITY, RELIABLE_ORDERED, 0, m_pcPacket->systemAddress, false);
}
}
}
break;
case ID_GAME_SETUP:
{
if (m_bHost)
{
Engine::CActor* pcPlayer = m_pcWorld->GetActorByName("PlayerCube");
Engine::CActor* pcPlayer2 = m_pcWorld->GetActorByName("PlayerCube2");
pcPlayer->SetDataMember("Status", "Enabled");
pcPlayer->SetDataMember("NetworkControl", "Enabled");
pcPlayer->SetMetricMember("LocationX", 0.0f);
pcPlayer->SetMetricMember("LocationY", 0.0f);
pcPlayer->SetMetricMember("LocationZ", -500.0f);
pcPlayer->SetMetricMember("RotationX", 0.0f);
pcPlayer->SetMetricMember("RotationY", 0.0f);
pcPlayer->SetMetricMember("RotationZ", 0.0f);
pcPlayer2->SetDataMember("Status", "Enabled");
pcPlayer2->SetDataMember("NetworkControl", "Disabled");
pcPlayer2->SetMetricMember("LocationX", 0.0f);
pcPlayer2->SetMetricMember("LocationY", 0.0f);
pcPlayer2->SetMetricMember("LocationZ", 500.0f);
pcPlayer2->SetMetricMember("RotationX", 0.0f);
pcPlayer2->SetMetricMember("RotationY", 180.0f);
pcPlayer2->SetMetricMember("RotationZ", 0.0f);
Engine::CActor* pcPlayer2Forward = m_pcWorld->GetActorByName("Player2Forward");
pcPlayer2Forward->SetDataMember("Status", "Enabled");
Engine::CActor* pcCamera = m_pcWorld->GetActorByName("Camera");
Engine::CActor* pcCamera2 = m_pcWorld->GetActorByName("Camera2");
pcCamera->SetDataMember("CameraStatus", "Enabled");
pcCamera2->SetDataMember("CameraStatus", "Disabled");
pcCamera->SetDataMember("LookAtStatus", "Enabled");
pcCamera2->SetDataMember("LookAtStatus", "Disabled");
Engine::CActor* pcScoreZone1 = m_pcWorld->GetActorByName("ScoreZone1");
Engine::CActor* pcScoreZone2 = m_pcWorld->GetActorByName("ScoreZone2");
pcScoreZone1->SetMetricMember("Score", 0.0f);
pcScoreZone2->SetMetricMember("Score", 0.0f);
pcScoreZone1->SetDataMember("TextStatus", "Enabled");
pcScoreZone2->SetDataMember("TextStatus", "Enabled");
size_t sztNetworkID = 2;
RakNet::BitStream bsOut;
bsOut.Write((RakNet::MessageID)ID_GAME_SETUP);
bsOut.Write(sztNetworkID);
m_pcPeer->Send(&bsOut, HIGH_PRIORITY, RELIABLE_ORDERED, 0, m_pcPacket->systemAddress, false);
}
else
{
Engine::CActor* pcPlayer = m_pcWorld->GetActorByName("PlayerCube");
Engine::CActor* pcPlayer2 = m_pcWorld->GetActorByName("PlayerCube2");
pcPlayer->SetDataMember("Status", "Enabled");
pcPlayer->SetDataMember("NetworkControl", "Disabled");
pcPlayer->SetMetricMember("LocationX", 0.0f);
pcPlayer->SetMetricMember("LocationY", 0.0f);
pcPlayer->SetMetricMember("LocationZ", -500.0f);
pcPlayer->SetMetricMember("RotationX", 0.0f);
pcPlayer->SetMetricMember("RotationY", 0.0f);
pcPlayer->SetMetricMember("RotationZ", 0.0f);
pcPlayer2->SetDataMember("Status", "Enabled");
pcPlayer2->SetDataMember("NetworkControl", "Enabled");
pcPlayer2->SetDataMember("Status", "Enabled");
pcPlayer2->SetMetricMember("LocationX", 0.0f);
pcPlayer2->SetMetricMember("LocationY", 0.0f);
pcPlayer2->SetMetricMember("LocationZ", 500.0f);
pcPlayer2->SetMetricMember("RotationX", 0.0f);
pcPlayer2->SetMetricMember("RotationY", 180.0f);
pcPlayer2->SetMetricMember("RotationZ", 0.0f);
pcPlayer2->SetInputMember("MovePositiveX", pcPlayer->GetInputMember("MovePositiveX"));
pcPlayer2->SetInputMember("MovePositiveY", pcPlayer->GetInputMember("MovePositiveY"));
pcPlayer2->SetInputMember("MovePositiveZ", pcPlayer->GetInputMember("MovePositiveZ"));
pcPlayer2->SetInputMember("MoveNegativeX", pcPlayer->GetInputMember("MoveNegativeX"));
pcPlayer2->SetInputMember("MoveNegativeY", pcPlayer->GetInputMember("MoveNegativeY"));
pcPlayer2->SetInputMember("MoveNegativeZ", pcPlayer->GetInputMember("MoveNegativeZ"));
pcPlayer2->SetInputMember("Run", pcPlayer->GetInputMember("Run"));
Engine::CActor* pcCamera = m_pcWorld->GetActorByName("Camera");
Engine::CActor* pcCamera2 = m_pcWorld->GetActorByName("Camera2");
pcCamera->SetDataMember("CameraStatus", "Disabled");
pcCamera2->SetDataMember("CameraStatus", "Enabled");
pcCamera->SetDataMember("LookAtStatus", "Disabled");
pcCamera2->SetDataMember("LookAtStatus", "Enabled");
Engine::CActor* pcScoreZone1 = m_pcWorld->GetActorByName("ScoreZone1");
Engine::CActor* pcScoreZone2 = m_pcWorld->GetActorByName("ScoreZone2");
pcScoreZone1->SetMetricMember("Score", 0.0f);
pcScoreZone2->SetMetricMember("Score", 0.0f);
pcScoreZone1->SetDataMember("TextStatus", "Enabled");
pcScoreZone2->SetDataMember("TextStatus", "Enabled");
Engine::CActor* pcStaminaBar1 = m_pcWorld->GetActorByName("StaminaBar1");
pcStaminaBar1->SetDataMember("ActiveState", "Game");
Engine::CActor* pcStaminaBar2 = m_pcWorld->GetActorByName("StaminaBar2");
pcStaminaBar2->SetDataMember("ActiveState", "Game");
Engine::CActor* pcPlayer2Forward = m_pcWorld->GetActorByName("Player2Forward");
pcPlayer2Forward->SetDataMember("Status", "Enabled");
}
}
break;
case ID_GAME_POSITION:
{
if (m_bHost)
{
float fX = 0.0f;
float fY = 0.0f;
float fZ = 0.0f;
float fLastHit = 0.0f;
RakNet::BitStream bsIn(m_pcPacket->data, m_pcPacket->length, false);
bsIn.IgnoreBytes(sizeof(RakNet::MessageID));
bsIn.Read(fX);
bsIn.Read(fY);
bsIn.Read(fZ);
Engine::CActor* pcPlayer2 = m_pcWorld->GetActorByName("PlayerCube2");
pcPlayer2->SetMetricMember("LocationX", fX);
pcPlayer2->SetMetricMember("LocationY", fY);
pcPlayer2->SetMetricMember("LocationZ", fZ);
m_pcWorld->ResetTimer();
}
else
{
float fX = 0.0f;
float fY = 0.0f;
float fZ = 0.0f;
float fPlaySound = -1.0f;
RakNet::BitStream bsIn(m_pcPacket->data, m_pcPacket->length, false);
bsIn.IgnoreBytes(sizeof(RakNet::MessageID));
bsIn.Read(fX);
bsIn.Read(fY);
bsIn.Read(fZ);
Engine::CActor* pcPlayer = m_pcWorld->GetActorByName("PlayerCube");
pcPlayer->SetMetricMember("LocationX", fX);
pcPlayer->SetMetricMember("LocationY", fY);
pcPlayer->SetMetricMember("LocationZ", fZ);
m_pcWorld->ResetTimer();
}
}
break;
case ID_GAME_ROTATION:
{
if (m_bHost)
{
float fX = 0.0f;
float fY = 0.0f;
float fZ = 0.0f;
RakNet::BitStream bsIn(m_pcPacket->data, m_pcPacket->length, false);
bsIn.IgnoreBytes(sizeof(RakNet::MessageID));
bsIn.Read(fX);
bsIn.Read(fY);
bsIn.Read(fZ);
Engine::CActor* pcPlayer2 = m_pcWorld->GetActorByName("PlayerCube2");
pcPlayer2->SetMetricMember("RotationX", fX);
pcPlayer2->SetMetricMember("RotationY", fY);
pcPlayer2->SetMetricMember("RotationZ", fZ);
m_pcWorld->ResetTimer();
}
else
{
float fX = 0.0f;
float fY = 0.0f;
float fZ = 0.0f;
RakNet::BitStream bsIn(m_pcPacket->data, m_pcPacket->length, false);
bsIn.IgnoreBytes(sizeof(RakNet::MessageID));
bsIn.Read(fX);
bsIn.Read(fY);
bsIn.Read(fZ);
Engine::CActor* pcPlayer = m_pcWorld->GetActorByName("PlayerCube");
pcPlayer->SetMetricMember("RotationX", fX);
pcPlayer->SetMetricMember("RotationY", fY);
pcPlayer->SetMetricMember("RotationZ", fZ);
m_pcWorld->ResetTimer();
}
}
break;
case ID_GAME_SCORE:
{
if (m_bHost)
{
float fScore = 0.0f;
RakNet::BitStream bsIn(m_pcPacket->data, m_pcPacket->length, false);
bsIn.IgnoreBytes(sizeof(RakNet::MessageID));
bsIn.Read(fScore);
Engine::CActor* pcScoreZone2 = m_pcWorld->GetActorByName("ScoreZone2");
pcScoreZone2->SetMetricMember("Score", fScore);
m_pcWorld->ResetTimer();
}
else
{
float fScore = 0.0f;
RakNet::BitStream bsIn(m_pcPacket->data, m_pcPacket->length, false);
bsIn.IgnoreBytes(sizeof(RakNet::MessageID));
bsIn.Read(fScore);
Engine::CActor* pcScoreZone1 = m_pcWorld->GetActorByName("ScoreZone1");
pcScoreZone1->SetMetricMember("Score", fScore);
m_pcWorld->ResetTimer();
}
}
break;
case ID_GAME_STAMINA:
{
if (m_bHost)
{
float fStamina = 0.0f;
RakNet::BitStream bsIn(m_pcPacket->data, m_pcPacket->length, false);
bsIn.IgnoreBytes(sizeof(RakNet::MessageID));
bsIn.Read(fStamina);
Engine::CActor* pcPlayer2 = m_pcWorld->GetActorByName("PlayerCube2");
pcPlayer2->SetMetricMember("Stamina", fStamina);
m_pcWorld->ResetTimer();
}
else
{
float fStamina = 0.0f;
RakNet::BitStream bsIn(m_pcPacket->data, m_pcPacket->length, false);
bsIn.IgnoreBytes(sizeof(RakNet::MessageID));
bsIn.Read(fStamina);
Engine::CActor* pcPlayer = m_pcWorld->GetActorByName("PlayerCube");
pcPlayer->SetMetricMember("Stamina", fStamina);
m_pcWorld->ResetTimer();
}
}
break;
case ID_SOUND_SPRINT:
{
bool bSprint = false;
RakNet::BitStream bsIn(m_pcPacket->data, m_pcPacket->length, false);
bsIn.IgnoreBytes(sizeof(RakNet::MessageID));
bsIn.Read(bSprint);
if (bSprint)
{
if (eae6320::UserSettings::IsSoundOn())
{
Engine::CActor* pcPlayer = nullptr;
if (m_bHost)
{
pcPlayer = m_pcWorld->GetActorByName("PlayerCube2");
}
else
{
pcPlayer = m_pcWorld->GetActorByName("PlayerCube");
}
float fX = pcPlayer->GetMetricMember("LocationX");
float fY = pcPlayer->GetMetricMember("LocationY");
float fZ = pcPlayer->GetMetricMember("LocationZ");
Shared::Math::CVector3 v3Position(fX, fY, fZ);
Shared::Math::CVector3 v3Velocity(0.0f, 0.0f, 0.0f);
m_pcSoundEngine->Play3D(m_pcSprintSound, m_pcSprintChannel, v3Position, v3Velocity);
m_pcSoundEngine->SetVolume(50.0f * eae6320::UserSettings::GetSoundVolumeLevel(), m_pcSprintChannel);
}
}
else
{
m_pcSoundEngine->Stop(m_pcSprintChannel);
}
m_pcWorld->ResetTimer();
}
break;
case ID_SOUND_WALK:
{
float fSurface = -1.0f;
bool bWalk = false;
RakNet::BitStream bsIn(m_pcPacket->data, m_pcPacket->length, false);
bsIn.IgnoreBytes(sizeof(RakNet::MessageID));
bsIn.Read(bWalk);
bsIn.Read(fSurface);
if (bWalk)
{
Engine::CActor* pcPlayer = nullptr;
if (m_bHost)
{
pcPlayer = m_pcWorld->GetActorByName("PlayerCube2");
}
else
{
pcPlayer = m_pcWorld->GetActorByName("PlayerCube");
}
float fX = pcPlayer->GetMetricMember("LocationX");
float fY = pcPlayer->GetMetricMember("LocationY");
float fZ = pcPlayer->GetMetricMember("LocationZ");
Shared::Math::CVector3 v3Position(fX, fY, fZ);
Shared::Math::CVector3 v3Velocity(0.0f, 0.0f, 0.0f);
switch (static_cast<int>(fSurface))
{
case 0:
if (eae6320::UserSettings::IsSoundOn())
{
m_pcSoundEngine->Play3D(m_pcGroundSound, m_pcGroundChannel, v3Position, v3Velocity);
m_pcSoundEngine->SetVolume(1.0f * eae6320::UserSettings::GetSoundVolumeLevel(), m_pcGroundChannel);
}
m_pcSoundEngine->Stop(m_pcStairChannel);
break;
case 1:
if (eae6320::UserSettings::IsSoundOn())
{
m_pcSoundEngine->Play3D(m_pcStairSound, m_pcStairChannel, v3Position, v3Velocity);
m_pcSoundEngine->SetVolume(1.0f * eae6320::UserSettings::GetSoundVolumeLevel(), m_pcStairChannel);
}
m_pcSoundEngine->Stop(m_pcGroundChannel);
break;
default:
m_pcSoundEngine->Stop(m_pcGroundChannel);
m_pcSoundEngine->Stop(m_pcStairChannel);
break;
}
}
else
{
m_pcSoundEngine->Stop(m_pcGroundChannel);
m_pcSoundEngine->Stop(m_pcStairChannel);
}
m_pcWorld->ResetTimer();
}
break;
default:
DEBUGPRINT("Message with identifier %i has arrived.\n", m_pcPacket->data[0]);
break;
}
}
return true;
}
bool Mob::CalculateNewPosition(float x, float y, float z, float speed, bool checkZ) {
if(GetID()==0)
return true;
float nx = x_pos;
float ny = y_pos;
float nz = z_pos;
// if NPC is rooted
if (speed == 0.0) {
SetHeading(CalculateHeadingToTarget(x, y));
if(moved){
SendPosition();
SetMoving(false);
moved=false;
}
SetRunAnimSpeed(0);
mlog(AI__WAYPOINTS, "Rooted while calculating new position to (%.3f, %.3f, %.3f)", x, y, z);
return true;
}
float old_test_vector=test_vector;
tar_vx = x - nx;
tar_vy = y - ny;
tar_vz = z - nz;
if (tar_vx == 0 && tar_vy == 0)
return false;
pRunAnimSpeed = (uint8)(speed*NPC_RUNANIM_RATIO);
speed *= NPC_SPEED_MULTIPLIER;
mlog(AI__WAYPOINTS, "Calculating new position to (%.3f, %.3f, %.3f) vector (%.3f, %.3f, %.3f) rate %.3f RAS %d", x, y, z, tar_vx, tar_vy, tar_vz, speed, pRunAnimSpeed);
// --------------------------------------------------------------------------
// 2: get unit vector
// --------------------------------------------------------------------------
test_vector=sqrtf (x*x + y*y + z*z);
tar_vector = speed / sqrtf (tar_vx*tar_vx + tar_vy*tar_vy + tar_vz*tar_vz);
heading = CalculateHeadingToTarget(x, y);
if (tar_vector >= 1.0) {
if(IsNPC()) {
entity_list.ProcessMove(CastToNPC(), x, y, z);
}
x_pos = x;
y_pos = y;
z_pos = z;
mlog(AI__WAYPOINTS, "Close enough, jumping to waypoint");
}
else {
float new_x = x_pos + tar_vx*tar_vector;
float new_y = y_pos + tar_vy*tar_vector;
float new_z = z_pos + tar_vz*tar_vector;
if(IsNPC()) {
entity_list.ProcessMove(CastToNPC(), new_x, new_y, new_z);
}
x_pos = new_x;
y_pos = new_y;
z_pos = new_z;
mlog(AI__WAYPOINTS, "Next position (%.3f, %.3f, %.3f)", x_pos, y_pos, z_pos);
}
uint8 NPCFlyMode = 0;
if(IsNPC()) {
if(CastToNPC()->GetFlyMode() == 1 || CastToNPC()->GetFlyMode() == 2)
NPCFlyMode = 1;
}
//fix up pathing Z
if(!NPCFlyMode && checkZ && zone->HasMap() && RuleB(Map, FixPathingZWhenMoving))
{
if(!RuleB(Watermap, CheckForWaterWhenMoving) || !zone->HasWaterMap() ||
(zone->HasWaterMap() && !zone->watermap->InWater(x_pos, y_pos, z_pos)))
{
Map::Vertex dest(x_pos, y_pos, z_pos);
float newz = zone->zonemap->FindBestZ(dest, nullptr) + 2.0f;
mlog(AI__WAYPOINTS, "BestZ returned %4.3f at %4.3f, %4.3f, %4.3f", newz,x_pos,y_pos,z_pos);
if( (newz > -2000) && ABS(newz - dest.z) < RuleR(Map, FixPathingZMaxDeltaMoving)) // Sanity check.
{
if(ABS(x - x_pos) < 0.5 && ABS(y - y_pos) < 0.5)
{
if(ABS(z - z_pos) <= RuleR(Map, FixPathingZMaxDeltaMoving))
z_pos = z;
else
z_pos = newz + 1;
}
else
z_pos = newz+1;
}
}
}
//OP_MobUpdate
if((old_test_vector!=test_vector) || tar_ndx>20){ //send update
tar_ndx=0;
this->SetMoving(true);
moved=true;
delta_x=(x_pos-nx);
delta_y=(y_pos-ny);
delta_z=(z_pos-nz);
delta_heading=0;//(heading-nh)*8;
SendPosUpdate();
}
tar_ndx++;
// now get new heading
SetAppearance(eaStanding, false); // make sure they're standing
pLastChange = Timer::GetCurrentTime();
return true;
}
void Player::SetCalculatePlayerPosition()
{
float speedXDeltaTime = m_speed * (float)GLOBAL::GetInstance().GetDeltaTime();
// Check collision between player and static boxes
OBB playerOBB;
playerOBB.m_radius = -1.0f;
if (GetBoundingBoxes().size() > 0)
{
playerOBB = GetBoundingBoxes()[0];
}
std::vector<OBB> collidingBoxes = CollisionManager::GetInstance()->CalculateLocalPlayerCollisionWithStaticBoxes(playerOBB, m_speed, m_direction);
for (unsigned int i = 0; i < collidingBoxes.size(); i++)
{
if (m_direction.x == 1 || m_direction.x == -1 || m_direction.z == 1 || m_direction.z == -1)
{
Sphere playerSphere = Sphere(m_position, m_playerSphere.m_radius - 0.1f);
playerSphere.m_position.x = m_position.x;
playerSphere.m_position.z = m_position.z - 1.0f * speedXDeltaTime;
bool down = CollisionManager::GetInstance()->CheckCollisionWithAllStaticObjects(playerSphere);
playerSphere.m_position.x = m_position.x;
playerSphere.m_position.z = m_position.z + 1.0f * speedXDeltaTime;
bool up = CollisionManager::GetInstance()->CheckCollisionWithAllStaticObjects(playerSphere);
playerSphere.m_position.x = m_position.x + 1.0f * speedXDeltaTime;
playerSphere.m_position.z = m_position.z;
bool right = CollisionManager::GetInstance()->CheckCollisionWithAllStaticObjects(playerSphere);
playerSphere.m_position.x = m_position.x - 1.0f * speedXDeltaTime;
playerSphere.m_position.z = m_position.z;
bool left = CollisionManager::GetInstance()->CheckCollisionWithAllStaticObjects(playerSphere);
if ((down && m_direction.z == -1) || (up && m_direction.z == 1) || (right && m_direction.x == 1) || (left && m_direction.x == -1))
{
SetDirection(DirectX::XMFLOAT3(0.0f, 0.0f, 0.0f));
}
}
else if (collidingBoxes.size() > 1)
{
if (CheckSidesIfMultipleCollisions() == true)
{
SetDirection(DirectX::XMFLOAT3(0.0f, 0.0f, 0.0f));
//SetPosition(DirectX::XMFLOAT3(m_position.x - m_direction.x * (float)GLOBAL::GetInstance().GetDeltaTime(), m_position.y, m_position.z - m_direction.z * (float)GLOBAL::GetInstance().GetDeltaTime()));
}
else
{
CalculatePlayerCubeCollision(collidingBoxes[i]);
}
}
else
{
CalculatePlayerCubeCollision(collidingBoxes[i]);
}
}
std::vector<Sphere> collidingSpheres = CollisionManager::GetInstance()->CalculateLocalPlayerCollisionWithStaticSpheres(m_playerSphere, m_speed, m_direction);
// Check collision between player and static spheres
for (unsigned int i = 0; i < collidingSpheres.size(); i++)
{
float r = collidingSpheres[i].m_radius;
float deltaZ = m_position.z - collidingSpheres[i].m_position.z;
float deltaX = m_position.x - collidingSpheres[i].m_position.x;
float angle = atan2f(deltaZ, deltaX);
float circleX = cosf(angle) * r;
float circleY = sinf(angle) * r;
float dz = collidingSpheres[i].m_position.z - m_position.z;
float dx = collidingSpheres[i].m_position.x - m_position.x;
float angle1 = atan2(dz, dx);
float angle2 = atan2(m_direction.z, m_direction.x);
float offset = angle1 - angle2;
// Special cases ftw. Dont ask!
if (angle1 < 0 && angle2 < 0)
{
offset *= -1;
}
if (angle2 >= 0 && angle1 < 0)
{
offset *= -1;
}
if (angle2 >= DirectX::XM_PIDIV2 && angle1 <= -DirectX::XM_PIDIV2)
{
offset *= -1;
}
if (angle2 <= -DirectX::XM_PIDIV2 && angle1 >= DirectX::XM_PIDIV2)
{
offset *= -1;
}
// Circle equation:
// circleX * X + circleY * Y = Radius * Radius
// Bryt ut så att y blir ensam
// Y = (Radius * Radius - circleX * X) / circleY
float yValue = (r * r - circleX * (circleX + offset)) / circleY;
DirectX::XMFLOAT3 dir = DirectX::XMFLOAT3((circleX + offset) - circleX, 0, yValue - circleY);
// Normalize
float length = sqrt(dir.x * dir.x + dir.z * dir.z);
dir.x = dir.x / length;
dir.z = dir.z / length;
SetDirection(dir);
}
if (collidingSpheres.size() > 1 || collidingSpheres.size() >= 1 && collidingBoxes.size() >= 1)
{
SetDirection(DirectX::XMFLOAT3(0.0f, 0.0f, 0.0f));
}
SendPosition(DirectX::XMFLOAT3(m_position.x + m_direction.x * speedXDeltaTime, m_position.y + m_direction.y * speedXDeltaTime, m_position.z + m_direction.z * speedXDeltaTime));
}
void Player::UpdateMe()
{
float angle = atan2(m_dashDirection.z, m_dashDirection.x);
DirectX::XMFLOAT3 position = DirectX::XMFLOAT3(m_position.x, 2.0f, m_position.z);
m_trail->Update(position, angle);
//Required for ambient 3D sounds
if (m_sound != nullptr){
m_sound->UpdateAmbientSound(m_position.x, m_position.y, m_position.z);
}
if (m_updateVisibility)
{
m_updateVisibility = false;
GraphicsEngine::UpdateVisibilityPolygon(Point(m_position.x, m_position.z), (float)GLOBAL::GetInstance().GetDeltaTime());
}
// Check values from server
if (Network::GetInstance()->IsConnected())
{
SetHealth(Network::GetInstance()->GetMyPlayer().currentHP);
SetMaxHealth(Network::GetInstance()->GetMyPlayer().maxHP);
SetIsAlive(Network::GetInstance()->GetMyPlayer().isAlive);
SetTeam(Network::GetInstance()->GetMyPlayer().team);
SetGuID(Network::GetInstance()->GetMyPlayer().guid);
//SetPosition(DirectX::XMFLOAT3(Network::GetInstance()->GetMyPlayer().x, Network::GetInstance()->GetMyPlayer().y, Network::GetInstance()->GetMyPlayer().z));
}
float directionAngle = DirectX::XMVector3AngleBetweenVectors(DirectX::XMLoadFloat3(&m_attackDir), DirectX::XMLoadFloat3(&m_direction)).m128_f32[0];
if (directionAngle > (3.14f * 0.625f))
{
m_speed = m_originalSpeed * 0.85f;
}
else
{
SetSpeed(m_originalSpeed);
}
for (unsigned int i = 0; i < m_stickyTrapList.size(); i++)
{
if (Collisions::SphereSphereCollision(m_playerSphere, m_stickyTrapList[i]->GetStickyTrapSphere()))
{
SetSpeed(m_speed * STICKY_TRAP_SLOW_PRECENTAGE);
break;
}
}
UpdateBlood();
// Don't update player if he is dead
if (!m_isAlive || Network::GetInstance()->GetMatchOver())
{
m_ability = m_noAbility;
// Animation None ?
UpdateAbilities();
UpdateAbilityBar();
AnimatedObject::ChangeAnimationState(AnimationState::None);
if (m_sound != nullptr && m_soundEmitter != nullptr){
m_sound->StopAmbientSound(m_soundEmitter);
}
return;
}
// Check for dash
if (Network::GetInstance()->HaveDashed())
{
// Calc distance
float dx = Network::GetInstance()->GetDashLocation().x - m_position.x;
float dz = Network::GetInstance()->GetDashLocation().z - m_position.z;
m_dashDistanceLeft = sqrt(dx * dx + dz * dz);
// Calc dir
DirectX::XMVECTOR tempVector = DirectX::XMLoadFloat3(&DirectX::XMFLOAT3(dx, 0, dz));
tempVector = DirectX::XMVector3Normalize(tempVector);
DirectX::XMStoreFloat3(&m_dashDirection, tempVector);
m_isDashing = true;
m_trail->StartEmiting();
}
// Dash movement
if (m_isDashing)
{
float distance = DASH_SPEED * m_speed * (float)GLOBAL::GetInstance().GetDeltaTime();
Sphere playerSphere = m_playerSphere;
playerSphere.m_position.x += m_dashDistanceLeft * m_dashDirection.x;
playerSphere.m_position.z += m_dashDistanceLeft * m_dashDirection.z;
if (!CollisionManager::GetInstance()->CheckCollisionWithAllStaticObjects(playerSphere))
{
if (distance >= m_dashDistanceLeft)
{
m_position.x += m_dashDistanceLeft * m_dashDirection.x;
m_position.z += m_dashDistanceLeft * m_dashDirection.z;
m_dashDistanceLeft = 0.0f;
m_isDashing = false;
Network::GetInstance()->SendAnimationState(AnimationState::None);
m_trail->StopEmiting();
}
else
{
m_position.x += (DASH_SPEED * m_speed * (float)GLOBAL::GetInstance().GetDeltaTime()) * m_dashDirection.x;
m_position.z += (DASH_SPEED * m_speed * (float)GLOBAL::GetInstance().GetDeltaTime()) * m_dashDirection.z;
m_dashDistanceLeft -= distance;
}
// If we dashed, update shadow shapes.
GraphicsEngine::UpdateVisibilityPolygon(Point(m_position.x, m_position.z), (float)GLOBAL::GetInstance().GetDeltaTime());
// Force network to send pos
Network::GetInstance()->SendLatestPos();
}
else
{
m_isDashing = false;
Network::GetInstance()->SendAnimationState(AnimationState::None);
m_trail->StopEmiting();
}
SendPosition(m_position);
}
// Move.
if ((CalculateDirection() || Network::GetInstance()->ConnectedNow()) && !m_isDashing)
{
SetCalculatePlayerPosition();
// If we moved, update shadow shapes.
GraphicsEngine::UpdateVisibilityPolygon(Point(m_position.x, m_position.z), (float)GLOBAL::GetInstance().GetDeltaTime());
//Update sound (walking)
m_sound->StartAmbientSound(m_soundEmitter);
m_soundEmitter->m_pos.x = position.x;
m_soundEmitter->m_pos.y = position.y;
m_soundEmitter->m_pos.z = position.z;
}
else{
m_sound->StopAmbientSound(m_soundEmitter);
}
m_playerSphere.m_position = m_position;
// Check if the player have made an invalid move
if (Network::GetInstance()->MadeInvalidMove())
{
PlayerNet myPlayer = Network::GetInstance()->GetMyPlayer();
SendPosition(DirectX::XMFLOAT3(myPlayer.x, myPlayer.y, myPlayer.z));
Network::GetInstance()->UpdatedMoveFromInvalidMove();
m_updateVisibility = true;
}
// Check if the player need to respawn
if (Network::GetInstance()->HasRespawned())
{
PlayerNet myPlayer = Network::GetInstance()->GetMyPlayer();
SendPosition(DirectX::XMFLOAT3(myPlayer.x, myPlayer.y, myPlayer.z));
Network::GetInstance()->SetHaveRespawned();
m_updateVisibility = true;
}
if (Settings::GetInstance()->m_apeToggle)
{
if (InputManager::GetInstance()->IsKeyClicked(VkKeyScan(VK_SPACE)))
{
m_onPressed = !m_onPressed;
GLOBAL::GetInstance().APE_ON = !m_onPressed;
}
}
else
{
if (InputManager::GetInstance()->IsKeyPressed(VkKeyScan(VK_SPACE)))
{
if (Settings::GetInstance()->m_apeEnabled)
{
m_onPressed = false;
GLOBAL::GetInstance().APE_ON = true;
}
else
{
m_onPressed = true;
GLOBAL::GetInstance().APE_ON = false;
}
}
else
{
if (Settings::GetInstance()->m_apeEnabled)
{
m_onPressed = true;
GLOBAL::GetInstance().APE_ON = false;
}
else
{
m_onPressed = false;
GLOBAL::GetInstance().APE_ON = true;
}
}
}
m_ability = m_noAbility;
CheckForSpecialAttack();
if (m_onPressed)
{
// Range attack
if (InputManager::GetInstance()->IsRightMousePressed())
{
// Check cd so m_ability does not get set if u have cooldown preventing other abilities to be casted.
if (m_rangeAttack->GetStacks() > 0 || m_rangeAttack->GetStacks() == -1)
{
m_ability = m_rangeAttack;
}
else
{
StillCDText();
}
}
// Melee attack
if (InputManager::GetInstance()->IsLeftMousePressed())
{
if ((float)m_meleeAttack->GetCooldown() <= 0.0f)
{
m_ability = m_meleeAttack;
}
else
{
StillCDText();
}
}
}
else
{
// Range attack
if (InputManager::GetInstance()->IsRightMouseClicked())
{
// Check cd so m_ability does not get set if u have cooldown preventing other abilities to be casted.
if (m_rangeAttack->GetStacks() > 0 || m_rangeAttack->GetStacks() == -1)
{
m_ability = m_rangeAttack;
}
else
{
StillCDText();
}
}
// Melee attack
if (InputManager::GetInstance()->IsLeftMouseClicked())
{
if ((float)m_meleeAttack->GetCooldown() <= 0.0f)
{
m_ability = m_meleeAttack;
}
else
{
StillCDText();
}
}
}
// Count down cooldowns
UpdateAbilities();
throwDistance = CollisionManager::GetInstance()->CalculateMouseDistanceFromPlayer(m_position);
if (m_ability != m_noAbility && m_globalCooldown <= 0.0f)
{
if (m_ability->Execute(throwDistance))
{
// Play ability animation if we did any
DoAnimation();
// Set global cooldown
m_globalCooldown = m_maxGlobalCooldown;
}
}
DealtDamageStruct temp = Network::GetInstance()->GetDealtDamage();
m_floatingText->SetDealtDamageText(temp.m_position ,temp.m_damage);
UpdateAbilityBar();
}
void Client::ZonePC(uint32 zoneID, uint32 instance_id, float x, float y, float z, float heading, uint8 ignorerestrictions, ZoneMode zm) {
bool ReadyToZone = true;
int iZoneNameLength = 0;
const char* pShortZoneName = nullptr;
char* pZoneName = nullptr;
pShortZoneName = database.GetZoneName(zoneID);
database.GetZoneLongName(pShortZoneName, &pZoneName);
SetPortExemption(true);
if(!pZoneName) {
Message(13, "Invalid zone number specified");
safe_delete_array(pZoneName);
return;
}
iZoneNameLength = strlen(pZoneName);
switch(zm) {
case EvacToSafeCoords:
case ZoneToSafeCoords:
x = zone->safe_x();
y = zone->safe_y();
z = zone->safe_z();
SetHeading(heading);
break;
case GMSummon:
zonesummon_x = x_pos = x;
zonesummon_y = y_pos = y;
zonesummon_z = z_pos = z;
SetHeading(heading);
zonesummon_id = zoneID;
zonesummon_ignorerestrictions = 1;
break;
case ZoneSolicited:
zonesummon_x = x;
zonesummon_y = y;
zonesummon_z = z;
SetHeading(heading);
zonesummon_id = zoneID;
zonesummon_ignorerestrictions = ignorerestrictions;
break;
case GateToBindPoint:
x = x_pos = m_pp.binds[0].x;
y = y_pos = m_pp.binds[0].y;
z = z_pos = m_pp.binds[0].z;
heading = m_pp.binds[0].heading;
break;
case ZoneToBindPoint:
x = x_pos = m_pp.binds[0].x;
y = y_pos = m_pp.binds[0].y;
z = z_pos = m_pp.binds[0].z;
heading = m_pp.binds[0].heading;
zonesummon_ignorerestrictions = 1;
LogFile->write(EQEMuLog::Debug, "Player %s has died and will be zoned to bind point in zone: %s at LOC x=%f, y=%f, z=%f, heading=%f", GetName(), pZoneName, m_pp.binds[0].x, m_pp.binds[0].y, m_pp.binds[0].z, m_pp.binds[0].heading);
break;
case SummonPC:
zonesummon_x = x_pos = x;
zonesummon_y = y_pos = y;
zonesummon_z = z_pos = z;
SetHeading(heading);
break;
case Rewind:
LogFile->write(EQEMuLog::Debug, "%s has requested a /rewind from %f, %f, %f, to %f, %f, %f in %s", GetName(), x_pos, y_pos, z_pos, rewind_x, rewind_y, rewind_z, zone->GetShortName());
zonesummon_x = x_pos = x;
zonesummon_y = y_pos = y;
zonesummon_z = z_pos = z;
SetHeading(heading);
break;
default:
LogFile->write(EQEMuLog::Error, "Client::ZonePC() received a reguest to perform an unsupported client zone operation.");
ReadyToZone = false;
break;
}
if(ReadyToZone) {
zone_mode = zm;
if(zm == ZoneToBindPoint) {
EQApplicationPacket* outapp = new EQApplicationPacket(OP_ZonePlayerToBind, sizeof(ZonePlayerToBind_Struct) + iZoneNameLength);
ZonePlayerToBind_Struct* gmg = (ZonePlayerToBind_Struct*) outapp->pBuffer;
// If we are SoF and later and are respawning from hover, we want the real zone ID, else zero to use the old hack.
//
if((GetClientVersionBit() & BIT_SoFAndLater) && (!RuleB(Character, RespawnFromHover) || !IsHoveringForRespawn()))
gmg->bind_zone_id = 0;
else
gmg->bind_zone_id = zoneID;
gmg->x = x;
gmg->y = y;
gmg->z = z;
gmg->heading = heading;
strcpy(gmg->zone_name, pZoneName);
outapp->priority = 6;
FastQueuePacket(&outapp);
safe_delete(outapp);
}
else if(zm == ZoneSolicited || zm == ZoneToSafeCoords) {
EQApplicationPacket* outapp = new EQApplicationPacket(OP_RequestClientZoneChange, sizeof(RequestClientZoneChange_Struct));
RequestClientZoneChange_Struct* gmg = (RequestClientZoneChange_Struct*) outapp->pBuffer;
gmg->zone_id = zoneID;
gmg->x = x;
gmg->y = y;
gmg->z = z;
gmg->heading = heading;
gmg->instance_id = instance_id;
gmg->type = 0x01; //an observed value, not sure of meaning
outapp->priority = 6;
FastQueuePacket(&outapp);
safe_delete(outapp);
}
else if(zm == EvacToSafeCoords) {
EQApplicationPacket* outapp = new EQApplicationPacket(OP_RequestClientZoneChange, sizeof(RequestClientZoneChange_Struct));
RequestClientZoneChange_Struct* gmg = (RequestClientZoneChange_Struct*) outapp->pBuffer;
// if we are in the same zone we want to evac to, client will not send OP_ZoneChange back to do an actual
// zoning of the client, so we have to send a viable zoneid that the client *could* zone to to make it believe
// we are leaving the zone, even though we are not. We have to do this because we are missing the correct op code
// and struct that should be used for evac/succor.
// 213 is Plane of War
// 76 is orignial Plane of Hate
// WildcardX 27 January 2008. Tested this for 6.2 and Titanium clients.
if(this->GetZoneID() == 1)
gmg->zone_id = 2;
else if(this->GetZoneID() == 2)
gmg->zone_id = 1;
else
gmg->zone_id = 1;
gmg->x = x;
gmg->y = y;
gmg->z = z;
gmg->heading = heading;
gmg->instance_id = instance_id;
gmg->type = 0x01; // '0x01' was an observed value for the type field, not sure of meaning
// we hide the real zoneid we want to evac/succor to here
zonesummon_id = zoneID;
outapp->priority = 6;
FastQueuePacket(&outapp);
safe_delete(outapp);
}
else {
if(zoneID == GetZoneID()) {
//properly handle proximities
entity_list.ProcessMove(this, x_pos, y_pos, z_pos);
proximity_x = x_pos;
proximity_y = y_pos;
proximity_z = z_pos;
//send out updates to people in zone.
SendPosition();
}
EQApplicationPacket* outapp = new EQApplicationPacket(OP_RequestClientZoneChange, sizeof(RequestClientZoneChange_Struct));
RequestClientZoneChange_Struct* gmg = (RequestClientZoneChange_Struct*) outapp->pBuffer;
gmg->zone_id = zoneID;
gmg->x = x;
gmg->y = y;
gmg->z = z;
gmg->heading = heading;
gmg->instance_id = instance_id;
gmg->type = 0x01; //an observed value, not sure of meaning
outapp->priority = 6;
FastQueuePacket(&outapp);
safe_delete(outapp);
}
_log(NET__DEBUG, "Player %s has requested a zoning to LOC x=%f, y=%f, z=%f, heading=%f in zoneid=%i", GetName(), x, y, z, heading, zoneID);
//Clear zonesummon variables if we're zoning to our own zone
//Client wont generate a zone change packet to the server in this case so
//They aren't needed and it keeps behavior on next zone attempt from being undefined.
if(zoneID == zone->GetZoneID() && instance_id == zone->GetInstanceID())
{
if(zm != EvacToSafeCoords && zm != ZoneToSafeCoords && zm != ZoneToBindPoint)
{
zonesummon_x = 0;
zonesummon_y = 0;
zonesummon_z = 0;
zonesummon_id = 0;
zonesummon_ignorerestrictions = 0;
zone_mode = ZoneUnsolicited;
}
}
}
safe_delete_array(pZoneName);
}
