rendered paste body#define _ITEMCODES
#include "HackMap.h"
LPSTR AddCommas(DOUBLE f, INT places)
{
static CHAR tmp[40];
LPSTR s;
INT i = 0;
if ((places < 0) || (places > 38))
{
tmp[0] = 0;
return tmp;
}
sprintf_s(tmp, "%#.*f", places, f);
s = strchr(tmp, '.');
if (!places)
*s = '\0';
while (--s > tmp)
{
if (i++ == 2)
{
if (s[-1] == '-') break;
i = 0;
memmove(s + 1, s, strlen(s) + 1);
*s = ',';
}
}
return tmp;
}
CFindItem::CFindItem(int ItemType)
{
switch (ItemType)
{
case LIFE_POTION:
for (unsigned int i = 0; i < ArraySize(wLifePotCodes); ++i)
ItemCodes.push_back(wLifePotCodes[i]);
break;
case MANA_POTION:
for (unsigned int i = 0; i < ArraySize(wManaPotCodes); ++i)
ItemCodes.push_back(wManaPotCodes[i]);
break;
case REJUVENATION:
for (unsigned int i = 0; i < ArraySize(wRejuvCodes); ++i)
ItemCodes.push_back(wRejuvCodes[i]);
break;
case TOWN_PORTAL:
for (unsigned int i = 0; i < ArraySize(wPortalCodes); ++i)
ItemCodes.push_back(wPortalCodes[i]);
break;
}
}
int CFindItem::NumberOfItems()
{
int nReturn = 0;
for (std::vector<WORD>::iterator it = CFindItem::ItemCodes.begin(); it != CFindItem::ItemCodes.end(); ++it)
{
for (UnitAny* pItem = Me->pInventory->pFirstItem; pItem; pItem = pItem->pItemData->pNextInvItem)
{
if (pItem->dwType = UNIT_ITEM)
{
if (pItem->dwTxtFileNo == 0x206 && GetUnitStat(pItem, STAT_AMMOQUANTITY) == 0)
continue;
if (pItem->dwTxtFileNo == (*it))
{
if (GetUnitStat(pItem, STAT_AMMOQUANTITY) > 0)
nReturn+= GetUnitStat(pItem, STAT_AMMOQUANTITY);
else
nReturn++;
}
}
}
}
return nReturn;
}
bool CFindItem::FindInventoryItem(UnitAny *&Item)
{
int nCurrentLocIndex = ArraySize(nItemLocations);
int nCurrentItemIndex = CFindItem::ItemCodes.size();
for (UnitAny* pItem = Me->pInventory->pFirstItem; pItem; pItem = pItem->pItemData->pNextInvItem)
{
if (pItem->dwType = UNIT_ITEM)
{
if (pItem->dwTxtFileNo == 0x206 && GetUnitStat(pItem, STAT_AMMOQUANTITY) == 0)
continue;
bool bFoundItem = false;
int nItemLocation = GetItemLocation(pItem);
for (unsigned int nLocIndex = 0; nLocIndex < ArraySize(nItemLocations) && !bFoundItem; ++nLocIndex)
{
if (nItemLocation == nItemLocations[nLocIndex])
{
for (unsigned int nCodeIndex = 0; nCodeIndex < CFindItem::ItemCodes.size() && !bFoundItem; ++nCodeIndex)
{
if (pItem->dwTxtFileNo == CFindItem::ItemCodes[nCodeIndex])
{
if (nCodeIndex < nCurrentItemIndex || nCodeIndex <= nCurrentItemIndex && nLocIndex < nCurrentLocIndex)
{
Item = pItem;
nCurrentLocIndex = nLocIndex;
nCurrentItemIndex = nCodeIndex;
if (nCurrentItemIndex == 0 && nCurrentLocIndex == 0)
return true;
bFoundItem = true;
}
}
}
}
}
}
}
return (Item != NULL);
}
int GetNumberOfItems(int nItemType)
{
CFindItem Item(nItemType);
return Item.NumberOfItems();
}
bool MakeTownPortal()
{
if (!IsTownLevel(GetUnitArea(Me)))
{
UnitAny* pPortal = NULL;
CFindItem Item(TOWN_PORTAL);
if (Item.FindInventoryItem(pPortal))
{
g_TownPortalTimer = GetTickCount();
g_PrintPortalsLeft = true;
UseItem(pPortal);
return true;
}
}
return false;
}
int GetItemLocation(UnitAny* pItem)
{
if(!pItem || !pItem->pItemData)
return -1;
switch(pItem->pItemData->ItemLocation)
{
case STORAGE_INVENTORY:
return STORAGE_INVENTORY;
case STORAGE_TRADE:
if(pItem->pItemData->NodePage == NODEPAGE_STORAGE)
return STORAGE_TRADE;
case STORAGE_CUBE:
return STORAGE_CUBE;
case STORAGE_STASH:
return STORAGE_STASH;
case STORAGE_NULL:
switch(pItem->pItemData->NodePage)
{
case NODEPAGE_EQUIP:
return STORAGE_EQUIP;
case NODEPAGE_BELTSLOTS:
return STORAGE_BELT;
}
}
return STORAGE_NULL;
}
int TownPortalsRemaining()
{
int nRemain = 0;
for (UnitAny* pItem = Me->pInventory->pFirstItem; pItem; pItem = pItem->pItemData->pNextInvItem)
{
CHAR szTemp[4] = {0};
if (!GetItemCode(pItem, szTemp, 3))
return NULL;
if (!_stricmp(szTemp,"tbk"))
nRemain+= GetUnitStat(pItem, STAT_AMMOQUANTITY);
if (!_stricmp(szTemp,"tsc"))
nRemain++;
}
return nRemain;
}
bool GetItemCode(UnitAny* pItem, LPSTR szBuffer, DWORD dwMax)
{
if (!pItem)
return FALSE;
ItemTxt* pTxt = D2COMMON_GetItemTxt(pItem->dwTxtFileNo);
::memcpy(szBuffer, pTxt->szCode, min(3, dwMax));
return (INT)strlen(szBuffer);
}
bool UseItem(UnitAny* pUnit)
{
if (pUnit)
{
if (GetItemLocation(pUnit) == STORAGE_BELT)
{
BYTE Packet[13] = {0};
Packet[0] = 0x26;
*(LPDWORD)&Packet[1] = pUnit->dwUnitId;
*(LPDWORD)&Packet[5] = 0;
*(LPDWORD)&Packet[9] = 0;
//D2NET_SendPacket(13,1,Packet);
SendGAMEPacket(Packet,13);
}
if (GetItemLocation(pUnit) == STORAGE_INVENTORY)
{
BYTE Packet[13] = {0};
Packet[0] = 0x20;
*(LPDWORD)&Packet[1] = pUnit->dwUnitId;
*(LPDWORD)&Packet[5] = Me->pPath->xPos;
*(LPDWORD)&Packet[9] = Me->pPath->yPos;
//D2NET_SendPacket(13,1,Packet);
SendGAMEPacket(Packet,13);
}
if (GetItemLocation(pUnit) == STORAGE_STASH || GetItemLocation(pUnit) == STORAGE_CUBE)
{
BYTE Packet[9] = {0};
Packet[0] = 0x27;
*(LPDWORD)&Packet[1] = Me->pInventory->dwLeftItemUid;
*(LPDWORD)&Packet[5] = pUnit->dwUnitId;
//D2NET_SendPacket(9,1,Packet);
SendGAMEPacket(Packet,9);
}
return true;
}
return false;
}
bool Interact(DWORD dwUnitId, DWORD dwType, bool bCheckOverride)
{
if (!bCheckOverride)
if (!GetUnit(dwUnitId, dwType))
return false;
BYTE pPacket[9] = {0};
pPacket[0] = 0x13;
*(LPDWORD)&pPacket[1] = dwType;
*(LPDWORD)&pPacket[5] = dwUnitId;
//D2NET_SendPacket(9,1,pPacket);
SendGAMEPacket(pPacket,9);
return true;
}
void UpdateAttribute(DWORD dwUnitId, BYTE Attribute, DWORD dwAmount)
{
if (dwAmount < 0 || dwAmount > 200)
return;
BYTE pPacket[10] = {0};
pPacket[0] = 0x20;
*(LPDWORD)&pPacket[1] = dwUnitId;
pPacket[5] = Attribute;
*(LPDWORD)&pPacket[6] = dwAmount;
D2NET_ReceivePacket(pPacket,10);
}
bool IsMoveSkill(DWORD dwSkillId)
{
switch ((WORD)dwSkillId)
{
case D2S_TELEPORT:
case D2S_CHARGE:
case D2S_LEAP:
case D2S_WHIRLWIND:
case D2S_DRAGONFLIGHT:
return true;
default:
return false;
}
}
void CopyPoint(POINT & ptCopy, WORD x, WORD y)
{
ptCopy.x = x;
ptCopy.y = y;
}
void GrabTargetPoint(POINT & ptGrab, UnitAny* pTarget)
{
switch (pTarget->dwType)
{
case UNIT_TYPE_OBJECT:
case UNIT_TYPE_TILE:
case UNIT_TYPE_ITEM:
CopyPoint(ptGrab,pTarget->pObjectPath ? (WORD)pTarget->pObjectPath->dwPosX : NULL,pTarget->pObjectPath ? (WORD)pTarget->pObjectPath->dwPosY : NULL);
break;
default:
CopyPoint(ptGrab,pTarget->pPath ? pTarget->pPath->xPos : NULL,pTarget->pPath ? pTarget->pPath->yPos : NULL);
break;
}
}
void CheckCounterAttack()
{
if (g_AutoReblind || g_AutoSmite)
{
g_PlayerList.Lock();
if (!g_PlayerList.empty())
g_CounterAttack = true;
g_PlayerList.Unlock();
}
}
bool UpdatePlayerTargetPos(LPBYTE pPacket)
{
if (!ClientReady(false))
return false;
DWORD dwPlayerId = NULL;
POINT ptUpdatePos = {0,0};
switch (pPacket[0])
{
case 0x0D: //player stop
dwPlayerId = *(LPDWORD)&pPacket[2];
CopyPoint(ptUpdatePos,*(LPWORD)&pPacket[7],*(LPWORD)&pPacket[9]);
break;
case 0x0F: //player move to x,y
dwPlayerId = *(LPDWORD)&pPacket[2];
ptUpdatePos.x = *(LPWORD)&pPacket[7];
ptUpdatePos.y = *(LPWORD)&pPacket[9];
break;
case 0x10: //player move to target
{
dwPlayerId = *(LPDWORD)&pPacket[2];
UnitAny *pTarget = GetUnit(*(LPDWORD)&pPacket[8], *(LPBYTE)&pPacket[7]);
if (pTarget)
GrabTargetPoint(ptUpdatePos,pTarget);
}
break;
case 0x4C: //player cast to target
{
dwPlayerId = *(LPDWORD)&pPacket[2];
if (IsMoveSkill(*(LPDWORD)&pPacket[6]))
{
UnitAny *pTarget = GetUnit(*(LPDWORD)&pPacket[10],*(LPBYTE)&pPacket[9]);
if (pTarget)
{
GrabTargetPoint(ptUpdatePos,pTarget);
if (pTarget->dwUnitId == Me->dwUnitId)
CheckCounterAttack();
}
}
}
break;
case 0x4D: //player cast to x,y
{
dwPlayerId = *(LPDWORD)&pPacket[2];
if (IsMoveSkill(*(LPWORD)&pPacket[6]))
CopyPoint(ptUpdatePos,*(LPWORD)&pPacket[11],*(LPWORD)&pPacket[13]);
g_PlayerList.Lock();
if (g_PlayerList.size())
if (dwPlayerId == g_PlayerList[g_CurrentTarget]->dwPlayerId)
if (GetDistance(Me->pPath->xPos,Me->pPath->yPos,*(LPWORD)&pPacket[11],*(LPWORD)&pPacket[13]) <= g_AutoReblind ? g_ReblindDistance : g_AutoSmiteDistance)
CheckCounterAttack();
g_PlayerList.Unlock();
}
break;
case 0x59: //player assign
{
dwPlayerId = *(LPDWORD)&pPacket[1];
CopyPoint(ptUpdatePos,*(LPWORD)&pPacket[22],*(LPWORD)&pPacket[24]);
}
break;
}
if (!Me || !dwPlayerId || dwPlayerId == Me->dwUnitId || !ptUpdatePos.x || !ptUpdatePos.y)
return false;
UnitAny* pPlayer = GetUnit(dwPlayerId,UNIT_PLAYER);
if (!pPlayer)
return false;
g_PlayerList.Lock();
for (unsigned int i = 0; i < g_PlayerList.size(); ++i)
if (g_PlayerList[i]->dwPlayerId == dwPlayerId)
g_PlayerList[i]->ptTarget = ptUpdatePos;
g_PlayerList.Unlock();
return true;
}