[C++] Passive Anticheat (TC 13669+)

[Wolf Officious 1382]

Upraveno pro: TrinityCore 13669 (ze dne 25.10.2011)

(Možná půjde i na starších/novějších revizích)

 

#######################################

#### _____ Passive Anticheat _____ ####

#######################################

Originál zde: http://code.google.com/p/passive-anticheat-for-tc/

 

Nerad bych se nějak extra rozepisoval o funkcích, co to všechno umí atd... Když to děláte ručně a jste začátečníci, je to docela složitá a rozsáhlá úprava zdrojáku, takže tomu věnujte maximální pozornost. Doporučuji Vám udělat si zálohu zdrojových kódů, aby jste se v případě chyby měli k čemu vrátit.

 

SQL:

Data příkazů - Tabulka `command` (patří do world DB):

 

REPLACE INTO `command` (`name`,`security`,`help`) VALUES
('anticheat global', '2', 'Syntax: .anticheat global returns the total amount reports and the average. (top three players)'),
('anticheat player', '2', 'Syntax: .anticheat player $name returns the players''s total amount of warnings, the average and the amount of each cheat type.'),
('anticheat handle', '2', 'Syntax: .anticheat handle [on|off] Turn on/off the AntiCheat-Detection .'),
('anticheat delete', '2', 'Syntax: .anticheat delete [deleteall|$name] Deletes the report records of all the players or deletes all the reports of player $name.');

 

Tabulky logování anti cheatu (patří do characters DB):

 

DROP TABLE IF EXISTS `cheat_first_report`;
CREATE TABLE `cheat_first_report` (
 `id` int(11) unsigned NOT NULL auto_increment,
 `guid` int(11) unsigned NOT NULL,
 `name` varchar(100) collate utf8_unicode_ci default NULL,
 `time` bigint(20) NOT NULL default '0',
 PRIMARY KEY  (`id`),
 KEY `guid` (`guid`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci AUTO_INCREMENT=1;

DROP TABLE IF EXISTS `cheat_reports`;
CREATE TABLE `cheat_reports` (
 `id` int(11) unsigned NOT NULL auto_increment,
 `guid` int(11) unsigned NOT NULL,
 `name` varchar(100) default NULL,
 `mapid` smallint(5) unsigned NOT NULL default '0',
 `position_x` float NOT NULL default '0',
 `position_y` float NOT NULL default '0',
 `position_z` float NOT NULL default '0',
 `report` varchar(100) default NULL,
 `time` bigint(20) NOT NULL default '0',
 PRIMARY KEY  (`id`),
 KEY `guid` (`guid`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci AUTO_INCREMENT=1;

DROP TABLE IF EXISTS `cheat_temp_reports`;
CREATE TABLE `cheat_temp_reports` (
 `id` int(11) unsigned NOT NULL auto_increment,
 `guid` int(11) unsigned NOT NULL,
 `name` varchar(100) default NULL,
 `mapid` smallint(5) unsigned NOT NULL default '0',
 `position_x` float NOT NULL default '0',
 `position_y` float NOT NULL default '0',
 `position_z` float NOT NULL default '0',
 `report` varchar(100) default NULL,
 `time` bigint(20) NOT NULL default '0',
 PRIMARY KEY  (`id`),
 KEY `guid` (`guid`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci AUTO_INCREMENT=1;

 

 

 

PATCH:

src/server/game/Chat/Commands/Level0.cpp

 

řádek 55 (cca) v metodě bool ChatHandler::HandleStartCommand(const char* /*args*/)

(přidejte jen řádky před kterými je +)

bool ChatHandler::HandleStartCommand(const char* /*args*/)
{
   Player* chr = m_session->GetPlayer();
+
+    // WLK - ANTICHEAT ---->>
+    if (chr->GetAreaId() == 876 && !chr->isGameMaster() && chr->GetPositionZ() < 15.0f)
+    {
+        SendSysMessage("You can't do that, you are jailed!");
+        SetSentErrorMessage(true);
+        return false;
+    }
+    // <<---- WLK - ANTICHEAT

   if (chr->isInFlight())
   {
       SendSysMessage(LANG_YOU_IN_FLIGHT);

 

 

src/server/game/Entities/Player/Player.cpp

 

řádek 860 (cca) - metoda destruktoru Player::~Player ()

(přidejte jen řádky před kterými je +)

Player::~Player ()
{
+    // WLK - ANTICHEAT ---->>
+    if (sWorld->getBoolConfig(CONFIG_ANTICHEAT_ENABLE))
+        CleanTempCheatReports();
+    // <<---- WLK - ANTICHEAT
+
   // it must be unloaded already in PlayerLogout and accessed only for loggined player
   //m_social = NULL;

řádek 900 (cca) - HNED ZA KONEC metody destruktoru Player::~Player (), přidejte následující metody:

// WLK - ANTICHEAT ---->>
bool Player::HasFirstReport()
{
   PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_ANTICHEAT_GET_CHEAT_FIRST_REPORT);
   stmt->setUInt64(0,GetGUIDLow());

   PreparedQueryResult result = CharacterDatabase.Query(stmt);

   if (result)
       return true;
   else 
       return false;
}

void Player::CleanTempCheatReports()
{
   for (uint8 uiI = 0; uiI < 2; uiI++)
   {
       PreparedStatement* stmt;

       if (uiI == 0)
           stmt = CharacterDatabase.GetPreparedStatement(CHAR_ANTICHEAT_DEL_CHEAT_FIRST_REPORT);
       else 
           stmt = CharacterDatabase.GetPreparedStatement(CHAR_ANTICHEAT_DEL_CHEATERS_TEMP); 

       stmt->setUInt64(0,GetGUIDLow());
       CharacterDatabase.Execute(stmt);
   }
}

void Player::WalkOnWaterHackDetection(MovementInfo& pOldPacket, MovementInfo& pNewPacket)
{
   if (HasAuraType(SPELL_AURA_FEATHER_FALL) || HasAuraType(SPELL_AURA_SAFE_FALL) || HasAuraType(SPELL_AURA_WATER_WALK))
       return;

   // 1066 -> Aquatic Form
   if (HasAura(1066))
       return;

   if (IsUnderWater())
       return;

   float water_level = GetBaseMap()->GetWaterLevel(GetPositionX(),GetPositionY());
   float water_level_diff = fabs(water_level - GetPositionZ());

   if (water_level_diff > 0.15f)
       return;

   // we like check heartbeat movements
   if (pNewPacket.GetMovementFlags() != GetUnitMovementFlags() || 
       pNewPacket.GetMovementFlags() != pOldPacket.GetMovementFlags())
       return;

   // if we have movementflag_waterwalking and not an aura for it, we are cheating.
   if (HasUnitMovementFlag(MOVEMENTFLAG_WATERWALKING) && !CanFlyAnticheat(pNewPacket) && !IsFlying())
   {
       sLog->outError("Cheater! WaterWalking guid %u name %s Latency %u",GetGUIDLow(),GetName(), GetSession()->GetLatency());
       ElaborateCheatReport(this,3);
   }
}

void Player::FlyHackDetection(MovementInfo& pOldPacket, MovementInfo& pNewPacket)
{
   if (HasAuraType(SPELL_AURA_FEATHER_FALL) || HasAuraType(SPELL_AURA_SAFE_FALL))
       return;

   if (IsFalling())
       return;

   // we like check heartbeat movements
   if (pNewPacket.GetMovementFlags() != GetUnitMovementFlags() || 
       pNewPacket.GetMovementFlags() != pOldPacket.GetMovementFlags())
       return;

   if (IsFlying() && !CanFlyAnticheat(pNewPacket))
   {
       // if the player has flying movement flags but no auras that add them; player is C H E A T I N G !!
       sLog->outError("Cheater! Fly guid %u name %s Latency %u",GetGUIDLow(),GetName(),GetSession()->GetLatency());
       ElaborateCheatReport(this,2);
   }
}

void Player::JumpHackDetection(uint32 uiOpcode)
{
   // if we receive 2 jump packets consecutively... it is wrong! The player is cheating.

   if (uiOpcode != MSG_MOVE_JUMP || GetLastOpcode() != MSG_MOVE_JUMP)
       return;

   ElaborateCheatReport(this,5);
}

/*
void Player::TeleportHackDetection(MovementInfo& pOldPacket, MovementInfo& pNewPacket, uint32 uiOpcode)
{

   sLog->outError("Opcode que viene %u, Opcode anterior %u", uiOpcode, GetLastOpcode());

   if (uiOpcode == 183 && GetLastOpcode() == 181)
   {

       sLog->outError("Opcode %u", uiOpcode);

       sLog->outError("OldPacket MovementFlags %u", pOldPacket.GetMovementFlags());
       sLog->outError("NewPacket MovementFlags %u", pNewPacket.GetMovementFlags());

       sLog->outError("OldPacket falltime %u", pOldPacket.fallTime);
       sLog->outError("NewPacket falltime %u", pNewPacket.fallTime);

       sLog->outError("CanFly %b",CanFlyAnticheat(pNewPacket));
       sLog->outError("IsFlying %b",IsFlying());

       sLog->outError("Old Z: %f New Z: %f",pOldPacket.pos.GetPositionZ(), pNewPacket.pos.GetPositionZ());
       uint8 uiMoveType = 0;

       if (IsFlying())
           uiMoveType = MOVE_FLIGHT;
       else if (IsUnderWater())
           uiMoveType = MOVE_SWIM;
       else 
           uiMoveType = MOVE_RUN;

       // core-side speed-rate: Speed / 7
       float fSpeedRate = GetSpeedRate(UnitMoveType(uiMoveType));
       // Calculate Distance2D
       float fDistance2d = pNewPacket.pos.GetExactDist2dSq(GetPositionX(),GetPositionY());

       // time between packets
       uint32 uiDiffTime =  getMSTimeDiff(pOldPacket.time, pNewPacket.time);

       // fClientRate = it is the player's rate calculated using the distance done by the player
       float fClientRate = (fDistance2d * 1000 / uiDiffTime) /  GetSpeed(UnitMoveType(uiMoveType));

       // fServerRate = it is the player's rate using the distance per second (core information)
       float fServerRate = GetSpeed(UnitMoveType(uiMoveType)) * uiDiffTime / 1000 + sWorld.getFloatConfig(CONFIG_ANTICHEAT_MAX_DISTANCE_DIFF_ALLOWED);

       sLog->outError("fSpeedRate: %f fDistance2d: %f uiDiffTime: %u fClientRate: %f fServerRate: %f",fSpeedRate,fDistance2d,uiDiffTime,fClientRate,fServerRate);


       if (fClientRate > fServerRate)
       {
           sLog->outError("TELEPORT 0");// teleport hack
           ElaborateCheatReport(this,4);
       }
   }
}
*/
bool Player::SpeedHackDetection(MovementInfo& pOldPacket, MovementInfo& pNewPacket, uint32 uiOpcode, float fLastSpeedRate)
{
   // strange packet
   if (uiOpcode == MSG_MOVE_SET_FACING)
       return false;

   // we like check heartbeat movements
   if (pNewPacket.GetMovementFlags() != GetUnitMovementFlags() || 
       pNewPacket.GetMovementFlags() != pOldPacket.GetMovementFlags())
       return false;

   // just to prevent false reports
   if (GetVehicle())
       return false;

   // the best way is checking the ip of the target, if it is the same this check should return.
   if (GetMotionMaster()->GetCurrentMovementGeneratorType() == TARGETED_MOTION_TYPE)
       return false;

   // it will make false reports
   if (IsFalling() && CanFlyAnticheat(pNewPacket))
       return false;

   // the same reason for IsFalling, just in case...
   if (HasAuraType(SPELL_AURA_FEATHER_FALL) || HasAuraType(SPELL_AURA_SAFE_FALL))
       return false;

   uint8 uiMoveType = 0;

   if (IsFlying())
       uiMoveType = MOVE_FLIGHT;
   else if (IsUnderWater())
       uiMoveType = MOVE_SWIM;
   else 
       uiMoveType = MOVE_RUN;

   // core-side speed-rate: Speed / 7
   float fSpeedRate = GetSpeedRate(UnitMoveType(uiMoveType));

   // in my opinion this var must be constant in each check to avoid false reports
   if (fLastSpeedRate != fSpeedRate)
       return false;

   // Calculate Distance2D
   float fDistance2d = pNewPacket.pos.GetExactDist2dSq(GetPositionX(),GetPositionY());

   // time between packets
   uint32 uiDiffTime =  getMSTimeDiff(pOldPacket.time, pNewPacket.time);

   // fClientRate = it is the player's rate calculated using the distance done by the player
   float fClientRate = (fDistance2d * 1000 / uiDiffTime) /  GetSpeed(UnitMoveType(uiMoveType));

   // fServerRate = it is the player's rate using the distance per second (core information)
   float fServerRate = GetSpeed(UnitMoveType(uiMoveType)) * uiDiffTime / 1000 + sWorld->getFloatConfig(CONFIG_ANTICHEAT_MAX_DISTANCE_DIFF_ALLOWED);

   if (fDistance2d > 0.0f && fClientRate >  fServerRate)
   {
       /*sLog->outError("-----------------");
       sLog->outError("(CORE-SIDE) SpeedRate %f", fSpeedRate);
       sLog->outError("(CORE-SIDE) Speed %f", GetSpeed(UnitMoveType(uiMoveType)));
       sLog->outError("(PLAYER-SIDE) PlayerRate  %f", fClientRate);
       sLog->outError("(PLAYER-SIDE) DiffTime  %u", uiDiffTime);
       sLog->outError("fServerRate: %f",fServerRate);
       sLog->outError("(PLAYER-SIDE) Distancia %f", fDistance2d);
       sLog->outError("(PLAYER-SIDE) GetSpeed %f", GetSpeed(UnitMoveType(uiMoveType)));
       sLog->outError("NEW POS: X %f Y %f",pNewPacket.pos.GetPositionX(), pNewPacket.pos.GetPositionY());
       sLog->outError("OLD POS: X %f Y %f",GetPositionX(),GetPositionY());
       sLog->outError("Mejor distancia: %f",pNewPacket.pos.GetExactDist2dSq(GetPositionX(),GetPositionY()));
       sLog->outError("time: %u", pNewPacket.time);
       sLog->outError("time1: %u", pNewPacket.t_time);
       sLog->outError("time2: %u", pNewPacket.t_time2);
       sLog->outError("OPCODE: %u",uiOpcode);*/

       sLog->outError("CHEATER! SpeedHack guid %u name %s Latency %u",GetGUIDLow(),GetName(), GetSession()->GetLatency());
       ElaborateCheatReport(this,1);

       return true;
   }

   return false;
}

void Player::ElaborateCheatReport(Player* pPlayer, uint8 uiCheatType)
{
   if (!pPlayer)
       return;

   // cheatType 1 == SpeedHack
   // cheatType 2 == FlyHack
   // cheatType 3 == WalkOnWaterHack
   // cheatType 4 == TeleportHack
   // cheatType 5 == JumpHack

   std::string strReportType;

   switch(uiCheatType)
   {
   case 1:
       strReportType = "Speed-Hack";
       break;
   case 2:
       strReportType = "Fly-Hack"; 
       break;
   case 3:
       strReportType = "WalkOnWater-Hack";
       break;
   case 4:
       strReportType = "Teleport-Hack";
       break;
   case 5:
       strReportType = "Jump-Hack";
       break;
   default:
       strReportType = "";
       break;
   }

   if (!HasFirstReport())
   {
       PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_ANTICHEAT_SET_CHEAT_FIRST_REPORT);
       stmt->setUInt64(0,GetGUIDLow());
       stmt->setString(1,GetName());
       stmt->setUInt64(2, uint64(time(NULL)));
       CharacterDatabase.Execute(stmt);
   }

   for (uint8 uiI = 0; uiI < 2; uiI++)
   {
       PreparedStatement* stmt;

       if (uiI == 0)
           stmt = CharacterDatabase.GetPreparedStatement(CHAR_ANTICHEAT_SET_CHEATERS);
       else 
           stmt = CharacterDatabase.GetPreparedStatement(CHAR_ANTICHEAT_SET_CHEATERS_TEMP);

       stmt->setUInt64(0,GetGUIDLow());
       stmt->setString(1,GetName());
       stmt->setUInt32(2,GetMapId());
       stmt->setFloat(3,GetPositionX());
       stmt->setFloat(4,GetPositionY());
       stmt->setFloat(5,GetPositionZ());
       stmt->setString(6,strReportType);
       stmt->setUInt64(7, uint64(time(NULL)));
       CharacterDatabase.Execute(stmt);
   }

   /*// teleport hack, if the player use this and is detected it will not create enough reports so... we will insert more than 1 report when this is detected.
   if (uiCheatType == 4)
   {
       uint32 uiValor = 100;
       for (uint8 uiI = 0; uiI < uiValor*2; uiI++)
       {
           PreparedStatement* stmt;

           if (uiI < uiValor)
               stmt = CharacterDatabase.GetPreparedStatement(CHAR_ANTICHEAT_SET_CHEATERS);
           else 
               stmt = CharacterDatabase.GetPreparedStatement(CHAR_ANTICHEAT_SET_CHEATERS_TEMP);

           stmt->setUInt64(0,GetGUIDLow());
           stmt->setString(1,GetName());
           stmt->setUInt32(2,GetMapId());
           stmt->setFloat(3,GetPositionX());
           stmt->setFloat(4,GetPositionY());
           stmt->setFloat(5,GetPositionZ());
           stmt->setString(6,strReportType);
           stmt->setUInt64(7, uint64(time(NULL)));
           CharacterDatabase.Execute(stmt);
       }
   }*/


   PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_ANTICHEAT_GET_CHEATERS_BY_GUID);
   stmt->setUInt32(0,this->GetGUIDLow());
   PreparedQueryResult result = CharacterDatabase.Query(stmt);
   uint32 warnings = 0;
   if (result)
   {
       do
       {
           Field* fields=result->Fetch();
           warnings = fields[0].GetUInt32();
       }
       while (result->NextRow());
   }

   if (warnings > sWorld->getIntConfig(CONFIG_ANTICHEAT_REPORTS_FOR_GM_WARNING) && 
       sWorld->getIntConfig(CONFIG_ANTICHEAT_REPORTS_FOR_GM_WARNING) >= 0)
   {
       // display warning at the center of the screen, hacky way.
       std::string str = "";
       str = "|cFFFFFC00[AC]|cFF00FFFF[|cFF60FF00" + std::string(pPlayer->GetName()) + "|cFF00FFFF] Possible cheater!";
       WorldPacket data(SMSG_NOTIFICATION, (str.size()+1));
       data << str;
       sWorld->SendGlobalGMMessage(&data);
   }
}

bool Player::CanFlyAnticheat(MovementInfo& pMovementInfo)
{
   if (IsUnderWater())
       return true;

   if (HasAuraType(SPELL_AURA_FLY) || 
       HasAuraType(SPELL_AURA_WATER_WALK) || 
       HasAuraType(SPELL_AURA_MOD_INCREASE_MOUNTED_FLIGHT_SPEED) || 
       HasAuraType(SPELL_AURA_MOD_INCREASE_FLIGHT_SPEED) ||
       HasAuraType(SPELL_AURA_FEATHER_FALL) ||
       HasAuraType(SPELL_AURA_SAFE_FALL))
       return true;

   if (Creature* pCreature = GetVehicleCreatureBase())
       if (pCreature->GetCreatureInfo()->InhabitType & INHABIT_AIR)
           return true;

   if (HasUnitMovementFlag(MOVEMENTFLAG_JUMPING) ||  pMovementInfo.HasMovementFlag(MOVEMENTFLAG_JUMPING) || GetMap()->GetGameObject(pMovementInfo.t_guid))
       return true;

   return false;
}
// <<---- WLK - ANTICHEAT

 

 

src/server/game/Entities/Player/Player.h

 

řádek 2485 (cca) - Vyhledejte řádky bez + na začátku a použijte je jako záchytné body k vložení řádků kódu označených znakem +

        void AddWhisperWhiteList(uint64 guid) { WhisperList.push_back(guid); }
       bool IsInWhisperWhiteList(uint64 guid);
+
+        /*********************************************************/
+        /***                 ANTICHEAT SYSTEM                  ***/
+        /*********************************************************/
+        // WLK - ANTICHEAT
+        float GetLastSpeedRate() { return fLastSpeedRate; }
+        uint32 GetLastOpcode() { return uiLastOpcode; }
+        MovementInfo& GetLastPacket() { return lastMovementInfo; }
+        void SaveLastPacket(MovementInfo& pMovementInfo) { lastMovementInfo = pMovementInfo; }
+        void SetLastSpeedRate(float fSpeedRateRate) { fLastSpeedRate = fSpeedRateRate; }
+        void SetLastOpcode(uint32 uiOpcode) { uiLastOpcode = uiOpcode; }
+        void ElaborateCheatReport(Player* pPlayer, uint8 uiReportType);
+        bool SpeedHackDetection(MovementInfo& pOldPacket, MovementInfo& pNewPacket, uint32 uiOpcode, float fLastSpeedRate);
+        void TeleportHackDetection(MovementInfo& pOldPacket, MovementInfo& pNewPacket, uint32 uiOpcode);
+        void FlyHackDetection(MovementInfo& pOldPacket, MovementInfo& pNewPacket);
+        void WalkOnWaterHackDetection(MovementInfo& pOldPacket, MovementInfo& pNewPacket);
+        void JumpHackDetection(uint32 uiOpcode);
+        bool CanFlyAnticheat(MovementInfo& pMovementInfo);
+        bool HasFirstReport();
+        void CleanTempCheatReports();
+        // <<---- WLK - ANTICHEAT

   protected:
       // Gamemaster whisper whitelist
       WhisperListContainer WhisperList;

řádek 2764 (cca) - Vyhledejte řádky bez + na začátku a použijte je jako záchytné body k vložení řádků kódu označených znakem +

        bool CanAlwaysSee(WorldObject const* obj) const;

       bool IsAlwaysDetectableFor(WorldObject const* seer) const;

       uint8 m_grantableLevels;

   private:
+        /*********************************************************/
+        /***                    ANTICHEAT SYSTEM               ***/
+        /*********************************************************/
+        // WLK - ANTICHEAT ---->>
+        float fLastSpeedRate;
+        uint32 uiLastOpcode;
+        MovementInfo lastMovementInfo;
+        // <<---- WLK - ANTICHEAT
+
       // internal common parts for CanStore/StoreItem functions
       InventoryResult CanStoreItem_InSpecificSlot(uint8 bag, uint8 slot, ItemPosCountVec& dest, ItemTemplate const* pProto, uint32& count, bool swap, Item* pSrcItem) const;
       InventoryResult CanStoreItem_InBag(uint8 bag, ItemPosCountVec& dest, ItemTemplate const* pProto, uint32& count, bool merge, bool non_specialized, Item* pSrcItem, uint8 skip_bag, uint8 skip_slot) const;

 

 

src/server/game/Server/Protocols/Handlers/MovementHandler.cpp

 

řádek 340 (cca) - v metodě void WorldSession::HandleMovementOpcodes(WorldPacket & recv_data)

(přidejte jen řádky před kterými je +)

    if (plMover && ((movementInfo.flags & MOVEMENTFLAG_SWIMMING) != 0) != plMover->IsInWater())
   {
       // now client not include swimming flag in case jumping under water
       plMover->SetInWater(!plMover->IsInWater() || plMover->GetBaseMap()->IsUnderWater(movementInfo.pos.GetPositionX(), movementInfo.pos.GetPositionY(), movementInfo.pos.GetPositionZ()));
   }

   /*----------------------*/
+
+    // WLK - ANTICHEAT CHECKS ---->>
+    if (sWorld->getBoolConfig(CONFIG_ANTICHEAT_ENABLE))
+    {
+        /*********************/
+        /* Exceptions:
+        In Flight
+        On Transport
+        Being Teleported
+        Can't free move
+        Is GameMaster
+        **********************/
+
+        // preventing escape from JAIL! MUAHAHHAHA
+        if (plMover && plMover->GetAreaId() == 876 && !plMover->isGameMaster() && plMover->GetPositionZ() < 15.0f)
+        {
+            if (movementInfo.pos.GetPositionZ() > 10.0f || 
+                movementInfo.pos.GetPositionZ() < -66.0f ||
+                movementInfo.pos.GetExactDist2d(16227.79f, 16403.40f) > 70.0f ||
+                plMover->GetBaseMap()->GetAreaId(movementInfo.pos.GetPositionX(), movementInfo.pos.GetPositionY(), movementInfo.pos.GetPositionZ()) != 876)
+            {
+                plMover->TeleportTo(1, 16226.5f, 16403.6f, -64.5f,3.2f);
+                return;
+            }
+        }
+
+        if (plMover && !plMover->isInFlight() && !plMover->GetTransport() && !plMover->IsBeingTeleported() && plMover->CanFreeMove() && !plMover->isGameMaster())
+        {
+            // speed hack detection called!
+            /*if (!*/plMover->SpeedHackDetection(plMover->GetLastPacket(), movementInfo, opcode, plMover->GetLastSpeedRate());//)
+            //plMover->TeleportHackDetection(plMover->GetLastPacket(), movementInfo, opcode);
+
+            plMover->JumpHackDetection(opcode);
+
+            if (plMover->isAlive())
+                plMover->WalkOnWaterHackDetection(plMover->GetLastPacket(), movementInfo);
+
+            // fly hack detection called!
+            plMover->FlyHackDetection(plMover->GetLastPacket(), movementInfo);
+        }
+
+        // save packet time for next control.
+        if (plMover)
+        {
+            uint8 uiMoveType = 0;
+
+            if (plMover->IsFlying())
+                uiMoveType = MOVE_FLIGHT;
+            else if (plMover->IsUnderWater())
+                uiMoveType = MOVE_SWIM;
+            else 
+                uiMoveType = MOVE_RUN;
+
+            plMover->SaveLastPacket(movementInfo);
+            plMover->SetLastSpeedRate(plMover->GetSpeedRate(UnitMoveType(uiMoveType)));//plMover->GetSpeed(UnitMoveType(uiMoveType)));//Rate(UnitMoveType(uiMoveType)));
+            plMover->SetLastOpcode(opcode);
+        }
+    }
+    // <<---- WLK - ANTICHEAT CHECKS

   /* process position-change */
   WorldPacket data(opcode, recv_data.size());
   movementInfo.time = getMSTime();
   movementInfo.guid = mover->GetGUID();
   WriteMovementInfo(&data, &movementInfo);
   mover->SendMessageToSet(&data, _player);

 

 

src/server/game/Spells/Spell.cpp

 

řádek 4555 (cca) - v metodě SpellCastResult Spell::CheckCast(bool strict)

(přidejte jen řádky před kterými je +)

SpellCastResult Spell::CheckCast(bool strict)
{
   // check death state
   if (!m_caster->isAlive() && !(m_spellInfo->Attributes & SPELL_ATTR0_PASSIVE) && !((m_spellInfo->Attributes & SPELL_ATTR0_CASTABLE_WHILE_DEAD) || (IsTriggered() && !m_triggeredByAuraSpell)))
       return SPELL_FAILED_CASTER_DEAD;
+
+    // WLK - ANTICHEAT ---->>
+    if (m_targets.GetUnitTarget() && m_targets.GetUnitTarget()->GetTypeId() == TYPEID_PLAYER)
+    {
+        Player* pPlayer = m_targets.GetUnitTarget()->ToPlayer();
+
+        if (pPlayer->GetAreaId() == 876 && !pPlayer->isGameMaster() && pPlayer->GetPositionZ() < 15.0f)
+        {
+            for (int i = 0; i < MAX_SPELL_EFFECTS; i++)
+                if (m_spellInfo->Effects[i].Effect == SPELL_EFFECT_TELEPORT_UNITS)
+                        return SPELL_FAILED_NOT_HERE;
+        }
+    }
+    // <<---- WLK - ANTICHEAT

   // check cooldowns to prevent cheating
   if (m_caster->GetTypeId() == TYPEID_PLAYER && !(m_spellInfo->Attributes & SPELL_ATTR0_PASSIVE))
   {
       //can cast triggered (by aura only?) spells while have this flag

 

 

src/server/game/World/World.cpp

 

řádek 1190 (cca) - v metodě void World::LoadConfigSettings(bool reload)

(přidejte jen řádky před kterými je +)

    // AutoBroadcast
   m_bool_configs[CONFIG_AUTOBROADCAST] = ConfigMgr::GetBoolDefault("AutoBroadcast.On", false);
   m_int_configs[CONFIG_AUTOBROADCAST_CENTER] = ConfigMgr::GetIntDefault("AutoBroadcast.Center", 0);
   m_int_configs[CONFIG_AUTOBROADCAST_INTERVAL] = ConfigMgr::GetIntDefault("AutoBroadcast.Timer", 60000);

   // MySQL ping time interval
   m_int_configs[CONFIG_DB_PING_INTERVAL] = ConfigMgr::GetIntDefault("MaxPingTime", 30);

   // misc
   m_bool_configs[CONFIG_PDUMP_NO_PATHS] = ConfigMgr::GetBoolDefault("PlayerDump.DisallowPaths", true);
   m_bool_configs[CONFIG_PDUMP_NO_OVERWRITE] = ConfigMgr::GetBoolDefault("PlayerDump.DisallowOverwrite", true);
+
+    // WLK - ANTICHEAT ---->>
+    m_bool_configs[CONFIG_ANTICHEAT_ENABLE] = ConfigMgr::GetBoolDefault("Anticheat.Enable", false);
+    m_int_configs[CONFIG_ANTICHEAT_MAX_DIFF_TIME] = ConfigMgr::GetIntDefault("Anticheat.MaxDiffTime", 1000); // not used at the moment
+    m_int_configs[CONFIG_ANTICHEAT_MIN_DIFF_TIME] = ConfigMgr::GetIntDefault("Anticheat.MinDiffTime", 50); // not used at the moment
+    m_int_configs[CONFIG_ANTICHEAT_REPORTS_FOR_GM_WARNING] = ConfigMgr::GetIntDefault("Anticheat.ReportsForGMWarnings",75);
+    m_float_configs[CONFIG_ANTICHEAT_MAX_DISTANCE_DIFF_ALLOWED] = ConfigMgr::GetFloatDefault("Anticheat.MaxMaxAllowedDistance",0.5f);
+    // <<---- WLK - ANTICHEAT

   sScriptMgr->OnConfigLoad(reload);
}

řádek 2695 (cca) - v metodě void World::ResetDailyQuests()

(přidejte jen řádky před kterými je +)

void World::ResetDailyQuests()
{
   sLog->outDetail("Daily quests reset for all characters.");
   CharacterDatabase.Execute("DELETE FROM character_queststatus_daily");
   for (SessionMap::const_iterator itr = m_sessions.begin(); itr != m_sessions.end(); ++itr)
       if (itr->second->GetPlayer())
           itr->second->GetPlayer()->ResetDailyQuestStatus();
+
+    // WLK - ANTICHEAT ---->>
+    CharacterDatabase.Execute("DELETE FROM cheat_reports;");
+    CharacterDatabase.Execute("DELETE FROM cheat_first_report;");
+    // <<---- WLK - ANTICHEAT

   // change available dailies
   sPoolMgr->ChangeDailyQuests();
}

 

 

src/server/game/World/World.h

 

řádek 160 (cca) - enum WorldBoolConfigs

(přidejte jen řádky před kterými je +)

    CONFIG_AUTOBROADCAST,
   CONFIG_ALLOW_TICKETS,
   CONFIG_DBC_ENFORCE_ITEM_ATTRIBUTES,
   CONFIG_PRESERVE_CUSTOM_CHANNELS,
   CONFIG_PDUMP_NO_PATHS,
   CONFIG_PDUMP_NO_OVERWRITE,
+    CONFIG_ANTICHEAT_ENABLE, // WLK - ANTICHEAT
   BOOL_CONFIG_VALUE_COUNT
};

řádek 180 (cca) - enum WorldFloatConfigs

(přidejte jen řádky před kterými je +)

    CONFIG_THREAT_RADIUS,
   CONFIG_CHANCE_OF_GM_SURVEY,
+    CONFIG_ANTICHEAT_MAX_DISTANCE_DIFF_ALLOWED, // WLK - ANTICHEAT
   FLOAT_CONFIG_VALUE_COUNT
};

řádek 310 (cca) - enum WorldIntConfigs

(přidejte jen řádky před kterými je +)

    CONFIG_DB_PING_INTERVAL,
   CONFIG_PRESERVE_CUSTOM_CHANNEL_DURATION,
   CONFIG_PERSISTENT_CHARACTER_CLEAN_FLAGS,
   CONFIG_MAX_INSTANCES_PER_HOUR,
+    CONFIG_ANTICHEAT_MAX_DIFF_TIME,          // WLK - ANTICHEAT
+    CONFIG_ANTICHEAT_MIN_DIFF_TIME,          // WLK - ANTICHEAT
+    CONFIG_ANTICHEAT_REPORTS_FOR_GM_WARNING, // WLK - ANTICHEAT
   INT_CONFIG_VALUE_COUNT
};

 

 

src/server/shared/Database/Implementation/CharacterDatabase.cpp

 

řádek 300 (cca) - v metodě void CharacterDatabaseConnection::DoPrepareStatements()

(přidejte jen řádky před kterými je +)

    //  For loading and deleting expired auctions at startup
   PREPARE_STATEMENT(CHAR_LOAD_EXPIRED_AUCTIONS, "SELECT id, auctioneerguid, itemguid, itemEntry, itemowner, buyoutprice, time, buyguid, lastbid, startbid, deposit FROM auctionhouse ah INNER JOIN item_instance ii ON ii.guid = ah.itemguid WHERE ah.time <= ?", CONNECTION_SYNCH)

+    // WLK - ANTICHEAT ---->>
+    PREPARE_STATEMENT(CHAR_ANTICHEAT_SET_CHEATERS, "INSERT INTO cheat_reports (`guid`,`name`,`mapid`,`position_x`,`position_y`,`position_z`,`report`,`time`) VALUES (?,?,?,?,?,?,?,?);", CONNECTION_ASYNC);
+    PREPARE_STATEMENT(CHAR_ANTICHEAT_SET_CHEATERS_TEMP, "INSERT INTO cheat_temp_reports (`guid`,`name`,`mapid`,`position_x`,`position_y`,`position_z`,`report`,`time`) VALUES (?,?,?,?,?,?,?,?);", CONNECTION_ASYNC);
+    PREPARE_STATEMENT(CHAR_ANTICHEAT_GET_CHEATERS, "SELECT A.`name` , count( * ) AS 'Repeticiones' FROM `characters` AS A, `cheat_reports` AS B WHERE A.`online` =1 AND A.`guid` = B.`guid` GROUP BY B.`guid` ORDER BY Repeticiones DESC LIMIT 0 , 3", CONNECTION_SYNCH);
+    PREPARE_STATEMENT(CHAR_ANTICHEAT_SET_CHEAT_FIRST_REPORT, "INSERT INTO cheat_first_report (`guid`,`name`,`time`) VALUES (?,?,?);", CONNECTION_ASYNC);
+    PREPARE_STATEMENT(CHAR_ANTICHEAT_GET_CHEATERS_AVERAGE, "SELECT A.`name` , CAST((SUM(B.time ) / count( * ) ) - C.time AS UNSIGNED) AS 'promedio' , CAST(count( * ) AS UNSIGNED) AS 'Repeticiones' FROM `characters` AS A, `cheat_temp_reports` AS B, cheat_first_report AS C WHERE A.`online` =1 AND A.`guid` = B.`guid` AND A.guid = C.guid GROUP BY B.`guid` ORDER BY Repeticiones  DESC LIMIT 0 , 3;", CONNECTION_SYNCH);
+    PREPARE_STATEMENT(CHAR_ANTICHEAT_GET_CHEAT_FIRST_REPORT, "SELECT * FROM cheat_first_report WHERE guid=?;", CONNECTION_SYNCH);
+    PREPARE_STATEMENT(CHAR_ANTICHEAT_DEL_CHEAT_FIRST_REPORT, "DELETE FROM cheat_first_report WHERE guid=?", CONNECTION_ASYNC);
+    PREPARE_STATEMENT(CHAR_ANTICHEAT_DEL_CHEATERS_TEMP, "DELETE FROM cheat_temp_reports WHERE guid=?", CONNECTION_ASYNC);
+    PREPARE_STATEMENT(CHAR_ANTICHEAT_DEL_CHEATERS, "DELETE FROM cheat_reports WHERE guid=?", CONNECTION_ASYNC);
+    PREPARE_STATEMENT(CHAR_ANTICHEAT_CLEAN_CHEAT_FIRST_REPORT, "DELETE FROM cheat_first_report;", CONNECTION_ASYNC);
+    PREPARE_STATEMENT(CHAR_ANTICHEAT_CLEAN_CHEATERS_TEMP, "DELETE FROM cheat_temp_reports", CONNECTION_ASYNC);
+    PREPARE_STATEMENT(CHAR_ANTICHEAT_CLEAN_CHEATERS, "DELETE FROM cheat_reports;", CONNECTION_ASYNC);
+
+    PREPARE_STATEMENT(CHAR_ANTICHEAT_GET_CHEATERS_AVERAGE_BY_GUID, "SELECT CAST((SUM(B.time ) / count( * ) ) - C.time AS UNSIGNED) AS 'promedio' , CAST(count( * ) AS UNSIGNED) AS 'Repeticiones' FROM `characters` AS A, `cheat_temp_reports` AS B, cheat_first_report AS C WHERE A.`online` =1 AND A.`guid` = B.`guid` AND A.guid = C.guid AND A.`guid`=? GROUP BY B.`guid` ORDER BY Repeticiones  DESC LIMIT 0 , 1;", CONNECTION_SYNCH);
+    PREPARE_STATEMENT(CHAR_ANTICHEAT_GET_CHEATERS_BY_GUID, "SELECT count( * ) AS 'Repeticiones' FROM `characters` AS A, `cheat_reports` AS B WHERE A.`online` =1 AND A.`guid` = B.`guid` AND A.`guid`=? GROUP BY B.`guid` ORDER BY Repeticiones DESC LIMIT 0 , 1", CONNECTION_SYNCH);
+    PREPARE_STATEMENT(CHAR_ANTICHEAT_GET_REPORTS_TYPE_BY_GUID, "SELECT report FROM cheat_reports WHERE guid=?;", CONNECTION_SYNCH);
+    // <<---- WLK - ANTICHEAT
}

 

 

src/server/shared/Database/Implementation/CharacterDatabase.h

 

řádek 278 (cca) - enum CharacterDatabaseStatements

(přidejte jen řádky před kterými je +)

    CHAR_LOAD_EXPIRED_AUCTIONS,
+
+    // WLK - ANTICHEAT ---->>
+    CHAR_ANTICHEAT_SET_CHEATERS,
+    CHAR_ANTICHEAT_GET_CHEATERS,
+    CHAR_ANTICHEAT_SET_CHEAT_FIRST_REPORT,
+    CHAR_ANTICHEAT_GET_CHEAT_FIRST_REPORT,
+    CHAR_ANTICHEAT_GET_CHEATERS_AVERAGE,
+    CHAR_ANTICHEAT_DEL_CHEAT_FIRST_REPORT,
+    CHAR_ANTICHEAT_SET_CHEATERS_TEMP,
+    CHAR_ANTICHEAT_DEL_CHEATERS_TEMP,
+    CHAR_ANTICHEAT_DEL_CHEATERS,
+
+    CHAR_ANTICHEAT_CLEAN_CHEAT_FIRST_REPORT,
+    CHAR_ANTICHEAT_CLEAN_CHEATERS_TEMP,
+    CHAR_ANTICHEAT_CLEAN_CHEATERS,
+
+    CHAR_ANTICHEAT_GET_CHEATERS_AVERAGE_BY_GUID,
+    CHAR_ANTICHEAT_GET_CHEATERS_BY_GUID,
+    CHAR_ANTICHEAT_GET_REPORTS_TYPE_BY_GUID,
+    // <<---- WLK - ANTICHEAT

   MAX_CHARACTERDATABASE_STATEMENTS,
};

#endif

 

 

 

COMMAND SCRIPT:

Vytvořte nový soubor - src/server/scripts/Commands/cs_anticheat.cpp

 

/* ScriptData
Name: anticheat_commandscript
%Complete: 100
Comment: AntiCheat commands
Category: commandscripts
EndScriptData */

#include "ScriptMgr.h"
//#include "ObjectMgr.h"
#include "Chat.h"
//#include "AccountMgr.h"

class anticheat_commandscript : public CommandScript
{
public:
   anticheat_commandscript() : CommandScript("anticheat_commandscript") { }

   ChatCommand* GetCommands() const
   {
       static ChatCommand anticheatCommandTable[] =
       {
           { "global",     SEC_GAMEMASTER,     true, &HandleAntiCheatGlobalCommand,    "", NULL },
           { "player",     SEC_GAMEMASTER,     true, &HandleAntiCheatPlayerCommand,    "", NULL },
           { "delete",     SEC_ADMINISTRATOR,  true, &HandleAntiCheatDeleteCommand,    "", NULL },
           { "handle",     SEC_ADMINISTRATOR,  true, &HandleAntiCheatHandleCommand,    "", NULL },
           { "jail",       SEC_GAMEMASTER,     true, &HandleAnticheatJailCommand,      "", NULL },
           { "warn",       SEC_GAMEMASTER,     true, &HandleAnticheatWarnCommand,      "", NULL },
           { NULL,         0,                 false, NULL,                             "", NULL }
       };

       static ChatCommand commandTable[] =
       {
           { "anticheat",  SEC_GAMEMASTER,     true, NULL,                             "", anticheatCommandTable},
           { NULL,         0,                 false, NULL,                             "", NULL }
       };

       return commandTable;
   }

   static bool HandleAnticheatWarnCommand(ChatHandler* handler, const char* args)
   {
       Player* pTarget = NULL;

       char* pTargetName = strtok((char*)args, " ");

       if(pTargetName)
       {
           //get player by name
           if (!handler->extractPlayerTarget(pTargetName, &pTarget))
               pTarget = handler->getSelectedPlayer();
       }

       if (!pTarget)
           return false;

       WorldPacket data;

       // need copy to prevent corruption by strtok call in LineFromMessage original string
       char* buf = strdup("The anticheat system has reported several times that you may be cheating. You will be monitored to confirm if this is accurate.");
       char* pos = buf;

       while (char* line = handler->LineFromMessage(pos))
       {
           handler->FillSystemMessageData(&data, line);
           pTarget->GetSession()->SendPacket(&data);
       }

       free(buf);
       return true;
   }

   static bool HandleAnticheatJailCommand(ChatHandler* handler, const char* args)
   {
       Player* pTarget = NULL;

       char* pTargetName = strtok((char*)args, " ");

       if(pTargetName)
       {
           //get player by name
           if (!handler->extractPlayerTarget(pTargetName, &pTarget))
               pTarget = handler->getSelectedPlayer();
       }

       if (!pTarget)
       {
           handler->SendSysMessage(LANG_PLAYER_NOT_FOUND);
           handler->SetSentErrorMessage(true);
           return false;
       }

       if (pTarget == handler->GetSession()->GetPlayer())
           return false;

       // teleport both to jail.
       pTarget->TeleportTo(1,16226.5f,16403.6f,-64.5f,3.2f);
       handler->GetSession()->GetPlayer()->TeleportTo(1,16226.5f,16403.6f,-64.5f,3.2f);

       WorldLocation loc;

       // the player should be already there, but no 
       // pTarget->GetPosition(&loc);

       loc.m_mapId = 1;
       loc.m_positionX = 16226.5f;
       loc.m_positionY = 16403.6f;
       loc.m_positionZ = -64.5f;
       loc.m_orientation = 3.2f;

       pTarget->SetHomebind(loc,876);
       return true;
   }

   static bool HandleAntiCheatDeleteCommand(ChatHandler* handler, const char* args)
   {
       std::string strCommand;

       char* command = strtok((char*)args, " "); //get entered name

       if (!command)
           return true;

       strCommand = command;

       if (strCommand.compare("deleteall") == 0)
       {
           uint8 uiStmt[3] = {CHAR_ANTICHEAT_CLEAN_CHEAT_FIRST_REPORT, CHAR_ANTICHEAT_CLEAN_CHEATERS_TEMP, CHAR_ANTICHEAT_CLEAN_CHEATERS};
           for (uint8 uiI = 0; uiI < 3; uiI++)
           {
               PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(uiStmt[uiI]);
               CharacterDatabase.Execute(stmt);
           }

       }
       else
       {
           Player* pPlayer;

           if (!handler->extractPlayerTarget(command, &pPlayer)) //get player by name
               handler->PSendSysMessage("Player doesn't exist");
           else
           {
               uint8 uiStmt[3] = {CHAR_ANTICHEAT_DEL_CHEATERS, CHAR_ANTICHEAT_DEL_CHEATERS_TEMP, CHAR_ANTICHEAT_DEL_CHEAT_FIRST_REPORT};

               for (uint8 uiI = 0; uiI < 3; uiI++)
               {
                   PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(uiStmt[uiI]);
                   stmt->setUInt64(0, pPlayer->GetGUIDLow());
                   CharacterDatabase.Execute(stmt);
               }
           }
       }

       return true;
   }

   static bool HandleAntiCheatPlayerCommand(ChatHandler* handler, const char* args)
   {
       std::string strCommand;

       char* command = strtok((char*)args, " ");

       uint32 uiGUID = 0;
       Player* pPlayer = NULL;

       if (command)
       {
           if (handler->extractPlayerTarget(command, &pPlayer)) //get player by name
               uiGUID = pPlayer->GetGUIDLow();
       }
       else 
       {
           pPlayer = handler->getSelectedPlayer();
           if (pPlayer)
               uiGUID = pPlayer->GetGUIDLow();  
       }

       if (uiGUID == 0)
       {
           handler->PSendSysMessage("There is no player.");
           return true;
       }

       PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_ANTICHEAT_GET_CHEATERS_BY_GUID);
       stmt->setUInt32(0, uiGUID);
       PreparedQueryResult result = CharacterDatabase.Query(stmt);

       if (result)
       {
           do {
               Field* fields=result->Fetch();
               uint32 warnings = fields[0].GetUInt32();
               handler->PSendSysMessage("Amount: %u", warnings);
           } while (result->NextRow());
       }
       else
           handler->PSendSysMessage("Player's amount log is empty!.");

       stmt = CharacterDatabase.GetPreparedStatement(CHAR_ANTICHEAT_GET_CHEATERS_AVERAGE_BY_GUID);
       stmt->setUInt32(0, uiGUID);
       result = CharacterDatabase.Query(stmt);

       if (result)
       {
           do {
               Field* fields=result->Fetch();
               uint32 average = fields[0].GetUInt32();
               uint32 warnings = fields[1].GetUInt32();

               handler->PSendSysMessage("Average: %u Warnings: %u", average, warnings);
           } while (result->NextRow());
       }
       else
           handler->PSendSysMessage("Player's average log is empty!.");


       stmt = CharacterDatabase.GetPreparedStatement(CHAR_ANTICHEAT_GET_REPORTS_TYPE_BY_GUID);
       stmt->setUInt32(0, uiGUID);
       result = CharacterDatabase.Query(stmt);

       uint32 uiReportsAmount[5] = {0, 0, 0, 0, 0};

       if (result)
       {
           do {
               Field* fields=result->Fetch();
               std::string report = fields[0].GetString();

               if (report.compare("Speed-Hack") == 0)
                   uiReportsAmount[0]++;
               else if (report.compare("Fly-Hack") == 0)
                   uiReportsAmount[1]++;
               else if (report.compare("WalkOnWater-Hack") == 0)
                   uiReportsAmount[2]++;
               else if (report.compare("Teleport-Hack") == 0)
                   uiReportsAmount[3]++;
               else if (report.compare("Jump-Hack") == 0)
                   uiReportsAmount[4]++;
           } while (result->NextRow());
       }

       handler->PSendSysMessage("Speed-Hack reports: %u || Fly-Hack reports: %u ||  WalkOnWater-Hack reports: %u || Teleport-Hack reports: %u || Jump-Hack reports: %u", uiReportsAmount[0],uiReportsAmount[1],uiReportsAmount[2],uiReportsAmount[3],uiReportsAmount[4]);

       return true;
   }

   static bool HandleAntiCheatHandleCommand(ChatHandler* handler, const char* args)
   {
       std::string strCommand;

       char* command = strtok((char*)args, " ");

       if (!command)
           return true;

       if (!handler->GetSession()->GetPlayer())
           return true;

       strCommand = command;

       if (strCommand.compare("on") == 0)
       {
           sWorld->setBoolConfig(CONFIG_ANTICHEAT_ENABLE,true);
           handler->SendSysMessage("The AntiCheat-System is now: Enabled!");
       }
       else if (strCommand.compare("off") == 0)
       {
           sWorld->setBoolConfig(CONFIG_ANTICHEAT_ENABLE,false);
           handler->SendSysMessage("The AntiCheat-System is now: Disabled!");
       }

       return true;
   }

   static bool HandleAntiCheatGlobalCommand(ChatHandler* handler, const char* args)
   {
       PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_ANTICHEAT_GET_CHEATERS);
       PreparedQueryResult result = CharacterDatabase.Query(stmt);

       handler->PSendSysMessage("Cheaters by Amount: -------------");
       if (result)
       {
           do {
               Field* fields=result->Fetch();
               std::string name = fields[0].GetCString();
               uint32 warnings = fields[1].GetUInt32();

               handler->PSendSysMessage("Name: %s Warnings: %u", name.c_str(), warnings);
           } while (result->NextRow());
       }
       else
           handler->PSendSysMessage("Cheaters amount log empty!.");

       handler->PSendSysMessage("Cheaters by Average: -------------");

       stmt = CharacterDatabase.GetPreparedStatement(CHAR_ANTICHEAT_GET_CHEATERS_AVERAGE);
       result = CharacterDatabase.Query(stmt);

       if (result)
       {
           do {
               Field* fields=result->Fetch();
               std::string name = fields[0].GetCString();
               uint32 average = fields[1].GetUInt32();
               uint32 warnings = fields[2].GetUInt32();

               handler->PSendSysMessage("Name: %s  Average: %u Warnings: %u", name.c_str(), average, warnings);
           } while (result->NextRow());
       }
       else
           handler->PSendSysMessage("Cheaters average log empty!.");

       return true;
   }
};

void AddSC_anticheat_commandscript()
{
   new anticheat_commandscript();
}

 

 

Registrace scriptu v souboru src/server/game/Scripting/ScriptLoader.cpp

 

řádek 45 (cca) - Vyhledejte řádky bez + na začátku a použijte je jako záchytné body k vložení řádků kódu označených znakem +

void AddSC_SmartSCripts();

//Commands
+void AddSC_anticheat_commandscript(); // WLK - ANTICHEAT
void AddSC_account_commandscript();
void AddSC_achievement_commandscript();
void AddSC_debug_commandscript();

řádek 647 (cca) - ve funkci void AddCommandScripts()

(přidejte jen řádky před kterými je +)

void AddCommandScripts()
{
   AddSC_anticheat_commandscript(); // WLK - ANTICHEAT
   AddSC_account_commandscript();
   AddSC_achievement_commandscript();

 

 

 

CONFIG:

 

Následující řádky přidejte na konec souboru worldserver.conf

###################################################################################################################
# ANTI CHEAT
#
#   Anticheat.Enable
#        Enable Anticheat System
#        Default: 0 - off
#                 1 - on
#
#   Anticheat.MaxDiffTime
#        Default: 1000 ms
#
#   Anticheat.MinDiffTime
#        Default: 350 ms
#
#   Anticheat.MaxMaxAllowedDistance
#	    Default: 0.5 f
#
#   Anticheat.ReportsForGMWarnings
#	    Enable and set warnings (at which amount will allow the report) for ingame-report, -1 disables it
#	    Default: 75
#
#   (c)2010 http://code.google.com/p/passive-anticheat-for-tc/
#   (c)2011 Wolf Officious - remake for TC2 @ r13669
#
###################################################################################################################

Anticheat.Enable = 0
Anticheat.MaxDiffTime = 1000
Anticheat.MinDiffTime = 50
Anticheat.MaxMaxAllowedDistance = 0.5
Anticheat.ReportsForGMWarnings = 75

 

 

Jestli jsem něco omylem vynechal nebo zapomněl, mějte prosím pochopení - nejsem stroj (ikdyž - být strojem by bylo někdy super ).

Vidíte sami jak rozsáhlé to je - založení topicu mi dalo víc práce, než upravit to z rok starého kódu na novější.

 

Poznámkami v kódu // WLK - ANTICHEAT si nedělám nároky na autorská práva.

Kdo zná patche, který mi prošli pod rukama tak ví, že tyhle značky si dělám pro sebe kvůli orientaci v kódu.

Jediný místo, kde jsem se fakt podepsal, je config. To snad pochopíte.

 

Užívejte v míru.

Edited November 30, 2011 by Wolf Officious

[Henzigo 240]

Krása Až to předěláš ještě na oregon core, tak to se ti pokloním... Skvělá práce

[Wolf Officious 1382]

Krása Až to předěláš ještě na oregon core, tak to se ti pokloním... Skvělá práce

Poděkuj mimoňům z http://code.google.com/p/passive-anticheat-for-tc/

Ale víš jakej to je záhul to postovat? Něco šílenýho. Hodinku jsem to upravoval, takřka bez debugu a 3 hodiny o tom píšu topic.

Edited November 30, 2011 by Wolf Officious

[Wolf Officious 1382]

BUMP!

 

Opraven a předělán Command Script - nyní má vlastní soubor.

Ještě řeším bordel mezi SYNC/ASYNC statementy, ale vypadá to, že už se to chytlo.

+ Revize kódu, jenom nějaký detaily...

 

V dalších dnech to budu upravovat podle toho, na co narazil filipoliko na TC fóru a píše o tom zde: http://www.wowresource.eu/index.php?showtopic=23894&view=findpost&p=213703

 

Mimojiné, souběžně to předělávám pro OregonCore (drtivá většina je hotová) a právě teď to testuji. Můžou tam být chyby, ale budu se snažit je vyřešit a zveřejnit funkční verzi pro OC co nejdřív.

Edited November 30, 2011 by Wolf Officious

[Xardas123 45]

Mě tedy tento antihack nefunguje. Po úspěšné překompilování absolutně nereaguje jako by tam nebyl. Buď jsem někde udělal chybu, ale to netuším kde protože jsem vše důsledně kontroloval řádek po řádku a nebo to je tím že je kód už moc starý...