test

#include <thread>
#include <iostream>
#include <Windows.h>
#include <TlHelp32.h>

#define LOCAL_PLAYER_OFFSET		0x058AA260UL//1.2.7.2
#define ENTITY_LIST_OFFSET		0x05662928UL//1.2.7.2
#define MESSAGE_SENDER_OFFSET	0x01370C90UL//1.2.7.2
#define TRANSFER_ITEM_VTABLE	0x0383AC88UL//1.2.7.2

HMODULE Module = NULL;
HANDLE ModuleThread = NULL;
DWORD64 ProcessBase = 0;
CHAR ProcessExe[] = "Fallout76.exe";

class EntityListType
{
public:
	BYTE Padding0000[0x80];
	DWORD64 InteriorListPtr;//0x80
	DWORD64 InteriorListCheck;//0x88
	BYTE Padding0090[0x18];
	DWORD64 ExteriorListPtr;//0xA8
	DWORD64 ExteriorListCheck;//0xB0
};

class EntityList
{
public:
	BYTE Padding0000[0x78];
	DWORD64 ListPtr;//0x78
	BYTE Padding0080[0x8];
	DWORD ListSize;//0x88
};

class LocalPlayer
{
public:
	DWORD64 vtable;//0x0
	BYTE Padding0008[0x18];
	DWORD Formid;//0x20
	BYTE Padding0024[0xAC];
	float Pitch;//0xD0
	BYTE Padding00D4[0x4];
	float Yaw;//0xD8
	BYTE Padding00DC[0x4];
	float Position[3];//0xE0
	BYTE Padding00EC[0x3C];
	DWORD64 InventoryPtr;//0x128
	BYTE Padding0130[0x30];
	DWORD64 ReferencePtr;//0x160
	BYTE Padding0168[0xAE0];
	DWORD64 StashPtr;//0xC48
};

class Entity
{
public:
	DWORD64 vtable;//0x0
	BYTE Padding0008[0x18];
	DWORD Formid;//0x20
	BYTE Padding0024[0xAC];
	float Pitch;//0xD0
	BYTE Padding00D4[0x4];
	float Yaw;//0xD8
	BYTE Padding00DC[0x4];
	float Position[3];//0xE0
	BYTE Padding00EC[0x3C];
	DWORD64 InventoryPtr;//0x128
	BYTE Padding0130[0x30];
	DWORD64 ReferencePtr;//0x160
};

class Reference
{
public:
	DWORD64 vtable;//0x0
	BYTE Padding0008[0x18];
	DWORD Formid;//0x20
};

class Inventory
{
public:
	DWORD64 vtable;//0x0
	BYTE Padding0008[0x58];
	DWORD64 ItemArrayPtr;//0x60
	BYTE Padding0068[0x8];
	DWORD ItemArraySize;//0x70
};

class Item
{
public:
	DWORD64 ReferencePtr;//0x0
	BYTE Padding0008[0x8];
	DWORD64 DisplayPtr;//0x10
	BYTE Padding0018[0x8];
	DWORD Iterations;//0x20
	BYTE Padding0024[0x8];
	DWORD ItemId;//0x2C
	BYTE Padding0030[0x8];
};

class ItemCount
{
public:
	BYTE Padding0000[0x8];
	DWORD Count;//0x8
	BYTE Padding000C[0x4];
};

class TransferMessage
{
public:
	DWORD64 vtable;//0x0
	DWORD SrcFormid;//0x8
	DWORD DstFormid;//0xC
	DWORD ItemId;//0x10
	DWORD Amount;//0x14
	DWORD UnknownA;//0x18
	DWORD UnknownB;//0x1C
};

bool CheckFormid(DWORD Formid)
{
	return true;
}

bool SingleKeyToggle(DWORD KeyCode, bool* KeyToggle)
{
	if (GetAsyncKeyState(KeyCode))
	{
		if (!*KeyToggle)
		{
			*KeyToggle = true;
			return true;
		}
	}
	else
	{
		if (*KeyToggle)
		{
			*KeyToggle = false;
			return false;
		}
	}

	return false;
}

bool DoubleKeyToggle(DWORD KeyCodeA, DWORD KeyCodeB, bool* KeyToggle)
{
	if (GetAsyncKeyState(KeyCodeA))
	{
		return SingleKeyToggle(KeyCodeB, KeyToggle);
	}

	if (GetAsyncKeyState(KeyCodeB))
	{
		return SingleKeyToggle(KeyCodeA, KeyToggle);
	}

	return false;
}

bool Valid(DWORD64 ptr)
{
	if (ptr < 0x7FFF || ptr > 0x7FFFFFFFFFFF) return false;
	else return true;
}

DWORD64 GetClosestEntity(DWORD Formid)
{
	DWORD64 LocalPlayerPtr = *(DWORD64*)(ProcessBase + LOCAL_PLAYER_OFFSET);
	if (!Valid(LocalPlayerPtr)) return 0;

	LocalPlayer LocalPlayerData = *(LocalPlayer*)(LocalPlayerPtr);
	if (LocalPlayerData.Formid == 0x00000014) return 0;

	DWORD64 EntityListBuffer = *(DWORD64*)(ProcessBase + ENTITY_LIST_OFFSET);
	if (!Valid(EntityListBuffer)) return 0;

	EntityListType EntityListTypeData = *(EntityListType*)(EntityListBuffer);
	if (!Valid(EntityListTypeData.InteriorListPtr)) return 0;
	if (!Valid(EntityListTypeData.InteriorListCheck)) return 0;
	if (!Valid(EntityListTypeData.ExteriorListPtr)) return 0;
	if (!Valid(EntityListTypeData.ExteriorListCheck)) return 0;

	DWORD64 EntityListArrayPtr = 0;
	DWORD EntityListArraySize = 0;

	bool UseInteriorList = false;
	if (EntityListTypeData.InteriorListPtr != EntityListTypeData.InteriorListCheck)
	{
		UseInteriorList = true;
		EntityListArrayPtr = EntityListTypeData.InteriorListPtr;
		EntityListArraySize = 1;
	}

	bool UseExteriorList = false;
	if (EntityListTypeData.ExteriorListPtr != EntityListTypeData.ExteriorListCheck)
	{
		UseExteriorList = true;
		EntityListArrayPtr = EntityListTypeData.ExteriorListPtr;
		EntityListArraySize = 25;
	}

	if (UseInteriorList && UseExteriorList) return 0;
	if (!UseInteriorList && !UseExteriorList) return 0;

	DWORD64* EntityListPtr = new DWORD64[EntityListArraySize * 2];
	memcpy(EntityListPtr, (DWORD64*)(EntityListArrayPtr), sizeof(DWORD64) * EntityListArraySize * 2);

	DWORD64 ClosestEntity = 0;
	float ClosestDistance = FLT_MAX;

	for (DWORD i = 0; i < EntityListArraySize; i++)
	{
		if (!Valid(EntityListPtr[i * 2])) continue;

		EntityList EntityListData = *(EntityList*)(EntityListPtr[i * 2]);
		if (!Valid(EntityListData.ListPtr) || EntityListData.ListSize == 0) continue;

		DWORD64 * EntityPtr = new DWORD64[EntityListData.ListSize];
		memcpy(EntityPtr, (DWORD64*)(EntityListData.ListPtr), sizeof(DWORD64) * EntityListData.ListSize);

		for (DWORD c = 0; c < EntityListData.ListSize; c++)
		{
			if (!Valid(EntityPtr[c])) continue;

			Entity EntityData = *(Entity*)(EntityPtr[c]);
			if (!Valid(EntityData.ReferencePtr) || EntityData.Formid == LocalPlayerData.Formid) continue;

			Reference ReferenceData = *(Reference*)(EntityData.ReferencePtr);
			if (ReferenceData.Formid != Formid) continue;

			float Difference[3];
			Difference[0] = EntityData.Position[0] - LocalPlayerData.Position[0];
			Difference[1] = EntityData.Position[1] - LocalPlayerData.Position[1];
			Difference[2] = EntityData.Position[2] - LocalPlayerData.Position[2];

			float Distance = sqrtf(powf(Difference[0], 2.0f) + powf(Difference[1], 2.0f) + powf(Difference[2], 2.0f));
			if (Distance >= ClosestDistance) continue;

			ClosestDistance = Distance;
			ClosestEntity = EntityPtr[c];
		}

		delete[]EntityPtr;
	}

	delete[]EntityListPtr;
	return ClosestEntity;
}

bool TransferArmor()
{
	DWORD64 ContainerPtr = GetClosestEntity(0x003C4115);
	if (ContainerPtr == 0) return false;

	Entity Container = *(Entity*)(ContainerPtr);
	if (!Valid(Container.InventoryPtr)) return false;

	DWORD64 LocalPlayerPtr = *(DWORD64*)(ProcessBase + LOCAL_PLAYER_OFFSET);
	if (!Valid(LocalPlayerPtr)) return false;

	LocalPlayer LocalPlayerData = *(LocalPlayer*)(LocalPlayerPtr);
	if (!Valid(LocalPlayerData.StashPtr)) return false;

	Entity STASH = *(Entity*)(LocalPlayerData.StashPtr);
	if (!Valid(STASH.InventoryPtr)) return false;

	Inventory InventoryData = *(Inventory*)(STASH.InventoryPtr);
	if (!Valid(InventoryData.ItemArrayPtr) || InventoryData.ItemArraySize == 0) return false;

	Item * ItemData = new Item[InventoryData.ItemArraySize];
	memcpy(ItemData, (DWORD64*)(InventoryData.ItemArrayPtr), InventoryData.ItemArraySize * sizeof(Item));

	typedef DWORD64(__fastcall MessageProc)(void* Message);
	MessageProc * SendMessageToServer = (MessageProc*)(ProcessBase + MESSAGE_SENDER_OFFSET);

	for (DWORD i = 0; i < InventoryData.ItemArraySize; i++)
	{
		if (!Valid(ItemData[i].ReferencePtr)) continue;
		if (!Valid(ItemData[i].DisplayPtr)) continue;
		if (ItemData[i].Iterations == 0) continue;

		Reference ReferenceData = *(Reference*)(ItemData[i].ReferencePtr);
		//if (!CheckFormid(ReferenceData.Formid)) continue;

		DWORD Amount = 0;
		ItemCount * ItemCountData = new ItemCount[ItemData[i].Iterations];
		memcpy(ItemCountData, (DWORD64*)(ItemData[i].DisplayPtr), ItemData[i].Iterations * sizeof(ItemCount));
		for (DWORD c = 0; c < ItemData[i].Iterations; c++) Amount += ItemCountData[c].Count;
		delete[]ItemCountData;

		TransferMessage TransferMessageData;
		TransferMessageData.vtable = ProcessBase + TRANSFER_ITEM_VTABLE;
		TransferMessageData.SrcFormid = STASH.Formid;
		TransferMessageData.DstFormid = Container.Formid;
		TransferMessageData.ItemId = ItemData[i].ItemId;
		TransferMessageData.Amount = Amount;
		TransferMessageData.UnknownA = 0;
		TransferMessageData.UnknownB = 0;
		SendMessageToServer(&TransferMessageData);
	}

	delete[]ItemData;
	return true;
}

void ModuleLoop()
{
	ProcessBase = DWORD64(GetModuleHandleA(ProcessExe));
	if (ProcessBase > 0)
	{
		bool ZeroKeyToggle = false;
		std::chrono::time_point<std::chrono::system_clock> ThreadTimer;
		while (!GetAsyncKeyState(VK_F1))
		{
			ThreadTimer = std::chrono::system_clock::now();

			if (DoubleKeyToggle(VK_CONTROL, '0', &ZeroKeyToggle))
			{
				TransferArmor();
			}

			ThreadTimer += std::chrono::milliseconds(16);
			std::this_thread::sleep_until(ThreadTimer);
		}
	}

	FreeLibraryAndExitThread(Module, 0);
}

BOOL DllMain(HMODULE hModule, DWORD dwReason, LPVOID lpReserved)
{
	switch (dwReason)
	{
	case DLL_PROCESS_ATTACH:
		Module = hModule;
		DisableThreadLibraryCalls(Module);
		ModuleThread = CreateThread(0, 0, LPTHREAD_START_ROUTINE(ModuleLoop), 0, 0, 0);
		CloseHandle(ModuleThread);
		break;
	case DLL_PROCESS_DETACH:
		break;
	default:
		break;
	}

	return TRUE;
}