GW Working Bots 2020

Func _EVT_SF_SalvageAll() ;->Verwertet alles im Inventar wieder

	Local $lBags
	Local $lSlots
	Local $lItem

	$EVT_STATUS = "Start Salvaging everything"

	For $lBags = 1 To 4

		For $lSlots = 1 To DllStructGetData(GetBag($lBags), 'slots')

			$lItem = GetItemBySlot($lBags, $lSlots)

			If Not _EVT_KF_CanSalvage($lItem) Then
				ContinueLoop
			EndIf

			If Not _EVT_SF_SalvageIt($lItem) Then
				Return False
			EndIf

		Next

	Next

	Return True

EndFunc   ;==>_EVT_SF_SalvageAll

Func _EVT_SF_SalvageIt($aItem) ;->Verwertet angegebenes Item Struct wieder

	Local $lR
	Local $lModelID
	Local $lSlot
	Local $lBag
	Local $lDingTimer
	Local $lIdent


	If _EVT_KF_CheckDead() Then
		Return $RETURN_ERROR_DIED
	EndIf

	If _EVT_SF_CountFreeBagSlots() = 0 Then
		$EVT_STATUS_FREESPACE = False
		Return $RETURN_ERROR_FAILEDTOSALVAGE
	EndIf

	If _EVT_SF_CountSalvageKit() = 0 Then
		$EVT_STATUS_SALVKIT = False
		Return $RETURN_ERROR_FAILEDTOSALVAGE
	EndIf

	If _EVT_SF_CountIDKit() = 0 Then
		$EVT_STATUS_IDENKIT = False
		Return $RETURN_ERROR_FAILEDTOSALVAGE
	EndIf

	$lModelID = DllStructGetData($aItem, 'ID')
	$aItem = _NF_GETITEM($lModelID)
	$lSlot = DllStructGetData($aItem, 'Slot') + 1
	$lBag = _NF_FindBag($lModelID, $lSlot)

	$aItem = GetItemBySlot($lBag, $lSlot)

	IdentifyItem($aItem)
	IdentifyBag($lBag)

	$dingTimer = TimerInit()
	Do
		Sleep(GetPing() + 10)
		$aItem = GetItemBySlot($lBag, $lSlot)
		$lIdent = GetIsIDed($aItem)
;~ 		_StatusMsg($ident)
	Until $lIdent = True Or TimerDiff($dingTimer) > 60000

	If TimerDiff($dingTimer) > 60000 Then
		Return False
	EndIf


	If $EVT_STATUS_SALVKIT Then

		$aItem = GetItemBySlot($lBag, $lSlot)

		$r = GetRarity($aItem)

		_StartNormSalvage($aItem)

		If $r = $EVT_RARITY_Purple Or $r = $EVT_RARITY_Gold Then

			Sleep(GetPing() + Random(150, 250))

			If _EVT_KF_CheckDead() Then
				If Not GetIsDead(-2) Then
					_EVT_NF_SENDKEY("{Enter}")
					DropItem(GetItemBySlot($lBag, $lSlot))
					Return False
				EndIf
			Else
				_EVT_NF_SENDKEY('{ENTER}')
			EndIf
		EndIf
		If _EVT_KF_CheckDead() Then
			Return False
		EndIf

		$lDingTimer = TimerInit()
		Do
			If Not Sleep(10) Then
				Return False
			EndIf
			$aItem = GetItemBySlot($lBag, $lSlot)
			$exitst = DllStructGetData($aItem, 'Type')
		Until $exitst = 0 Or $exitst = 11 Or TimerDiff($lDingTimer) > 60000

		If _EVT_KF_CheckDead() Then
			Return False
		EndIf

		If Not Sleep(Random(50, 70)) Then
			Return False
		EndIf

		Return True
	EndIf

	Return True

EndFunc   ;==>_EVT_SF_SalvageIt

;~ Description: Starts a salvaging session of an item with a normal salvage kit
Func _StartNormSalvage($aItem)
	Local $lOffset[4] = [0, 0x18, 0x2C, 0x690]
	Local $lSalvageSessionID = MemoryReadPtr($mBasePointer, $lOffset)

	If IsDllStruct($aItem) = 0 Then
		Local $lItemID = $aItem
	Else
		Local $lItemID = DllStructGetData($aItem, 'ID')
	EndIf

	Local $lSalvageKit = _FindNormSalvageKit()
	If $lSalvageKit = 0 Then Return

	DllStructSetData($mSalvage, 2, $lItemID)
	DllStructSetData($mSalvage, 3, $lSalvageKit)
	DllStructSetData($mSalvage, 4, $lSalvageSessionID[1])

	Enqueue($mSalvagePtr, 16)
EndFunc   ;==>_StartNormSalvage

void sellItemToMerchant(GW::Item *bItem) {
    if (!bItem) return;

    GW::Merchant::TransactionInfo give, recv;
    give.item_count = 1;
    give.item_ids = &bItem->item_id;
    give.item_quantities = nullptr;
    recv.item_count = 0;
    recv.item_ids = nullptr;
    recv.item_quantities = nullptr;

    GW::Merchant::TransactItems(GW::Merchant::TransactionType::MerchantSell,
                                0, give, bItem->quantity*bItem->value,
                                recv);
    std::chrono::milliseconds timespan(200);
    std::this_thread::sleep_for(timespan);
}

void identifyItem(GW::Item* bItem, GW::Item* kit) {
    if (!bItem || !kit) return;
    if ((bItem->interaction & 1) != 0) return; // is identified
    GW::CtoS::SendPacket(0xC, GAME_CMSG_ITEM_IDENTIFY, kit->item_id, bItem->item_id);
    std::chrono::milliseconds timespan(400);
    std::this_thread::sleep_for(timespan);
}

GW::Item* getSalvageKit() {
    for (size_t bag_index = static_cast<size_t>(GW::Constants::Bag::Backpack); bag_index < static_cast<size_t>(GW::Constants::Bag::Equipment_Pack); bag_index++) {
        GW::Bag* bag = nullptr;
        bag = GW::Items::GetBag(bag_index);
        if (!bag) continue;
        for (size_t slot_index = 0; slot_index < bag->items_count; slot_index++) {
            GW::Item* bItem = GW::Items::GetItemBySlot(bag, slot_index);
            if (!bItem) continue;
            for (size_t i = 0; i < bItem->mod_struct_size; i++) {
                GW::ItemModifier *mod = &bItem->mod_struct[i];
                if (mod->identifier() == 0x25E8) // is id kit
                    return bItem;
            }
        }
    }
    return nullptr;
}

bool filterItemToSell(GW::Item* bItem) {
    if (!bItem) return false;

    if (bItem->value <= 0) return false;
    if ((bItem->interaction & 0x10) != 0 ) return false; // is green
    if (bItem->type == static_cast<uint8_t>(GW::Constants::ItemType::Axe)) return true;
    if (bItem->type == static_cast<uint8_t>(GW::Constants::ItemType::Bow)) return true;
    if (bItem->type == static_cast<uint8_t>(GW::Constants::ItemType::Offhand)) return true;
    if (bItem->type == static_cast<uint8_t>(GW::Constants::ItemType::Hammer)) return true;
    if (bItem->type == static_cast<uint8_t>(GW::Constants::ItemType::Wand)) return true;
    if (bItem->type == static_cast<uint8_t>(GW::Constants::ItemType::Shield)) return true;
    if (bItem->type == static_cast<uint8_t>(GW::Constants::ItemType::Staff)) return true;
    if (bItem->type == static_cast<uint8_t>(GW::Constants::ItemType::Sword)) return true;
    if (bItem->type == static_cast<uint8_t>(GW::Constants::ItemType::Daggers)) return true;
    if (bItem->type == static_cast<uint8_t>(GW::Constants::ItemType::Scythe)) return true;
    if (bItem->type == static_cast<uint8_t>(GW::Constants::ItemType::Spear)) return true;

    return false;
}

void sellInventory() {
    GW::Item* item = nullptr;
    size_t items_found = 0;
    for (size_t bag_index = static_cast<size_t>(GW::Constants::Bag::Backpack); bag_index < static_cast<size_t>(GW::Constants::Bag::Equipment_Pack); bag_index++) {
        GW::Bag* bag = nullptr;
        bag = GW::Items::GetBag(bag_index);
        if (!bag) continue;
        GW::ItemArray items = bag->items;
        items_found = 0;
        for (size_t i = 0; i < items.size() && items_found < bag->items_count; i++) {
            item = static_cast<GW::Item*>(items[i]);
            if (!item) continue;
            if (!filterItemToSell(item)) continue;
            GW::Item *kit = getSalvageKit();
            identifyItem(item, kit);
            sellItemToMerchant(item);
        }
    }
}