Quote from B0nes on April 24, 2022, 1:44 pm

the rune pouch is supposed to store up to 16000 of 3 types of runes, not steal your runes when adding more than you have...

this will actually make it do that:

pouch.java

Code:

package ethos.model.content;

import java.util.Iterator;
import java.util.List;
import java.util.Objects;

import ethos.Server;
import ethos.model.content.LootingBag.LootingBagItem;
import ethos.model.entity.Entity;
import ethos.model.multiplayer_session.MultiplayerSessionFinalizeType;
import ethos.model.multiplayer_session.MultiplayerSessionStage;
import ethos.model.multiplayer_session.MultiplayerSessionType;
import ethos.model.multiplayer_session.duel.DuelSession;
import ethos.model.players.Player;



public abstract class Pouch {
	public Player player;
	
	void handleDeath(Player player,String entity,List<LootingBagItem>items){
		Entity killer = player.getKiller();
		for (Iterator<LootingBagItem> iterator=items.iterator(); iterator.hasNext();) {
			LootingBagItem item = iterator.next();

			if (item == null) {
				continue;
			}
			if (item.getId() <= 0 || item.getAmount() <= 0) {
				continue;
			}
			if (entity.equals("PVP")) {
				if (killer != null && killer instanceof Player) {
					Player playerKiller = (Player) killer;
					if (playerKiller.getMode().isItemScavengingPermitted()) {
						Server.itemHandler.createGroundItem(playerKiller, item.getId(), player.getX(), player.getY(), player.heightLevel, item.getAmount(), player.killerId);
					} else {
						Server.itemHandler.createUnownedGroundItem(item.getId(), player.getX(), player.getY(), player.heightLevel, item.getAmount());
					}
				}
			} else {
				Server.itemHandler.createGroundItem(player, item.getId(), player.getX(), player.getY(),
				                                    player.heightLevel, item.getAmount(), player.getIndex());
			}
			iterator.remove();
		}
	}

	int countItems(int id,List<LootingBagItem> items) {
		int count = 0;
		for (LootingBagItem item : items) {
			if (item.getId() == id) {
				count += item.getAmount();
			}
		}
		return count;
	}

	void withdrawItems(List<LootingBagItem>items){
		if (!configurationPermitted()) {
			player.sendMessage("You cannot do this right now.");
			return;
		}
		for (Iterator<LootingBagItem> iterator = items.iterator(); iterator.hasNext();) {
			LootingBagItem item = iterator.next();
			if (!player.getItems().addItem(item.getId(), item.getAmount())) {
				break;
			}
			iterator.remove();
		}
	}

	boolean sackContainsItem(int id,List<LootingBagItem> items) {
		for (LootingBagItem item : items) {
			if (item.getId() == id) {
				return true;
			}
		}
		return false;
	}

	
	boolean addItemToList(int id, int amount,List<LootingBagItem> items) {
		for (LootingBagItem item : items) { 
			if (item.getId() == id) {
				if (player.getItems().isStackable(id)) {
					item.incrementAmount(amount);
					return false;
				}
			}
		}
		items.add(new LootingBagItem(id, amount)); 
		//player.se
		return true;
	}

	boolean configurationPermitted() {
		if (player.inPcGame() || player.inPcBoat() || player.isInJail() || player.getInterfaceEvent().isActive() || player.getPA().viewingOtherBank
				|| player.isDead || player.viewingLootBag || player.addingItemsToLootBag) {
			return false;
		}
		if (player.getBankPin().requiresUnlock()) {
			player.getBankPin().open(2);
			return false;
		}
		if (player.getTutorial().isActive()) {
			player.getTutorial().refresh();
			return false;
		}
		DuelSession duelSession = (DuelSession) Server.getMultiplayerSessionListener().getMultiplayerSession(player, MultiplayerSessionType.DUEL);
		if (Objects.nonNull(duelSession) && duelSession.getStage().getStage() > MultiplayerSessionStage.REQUEST
				&& duelSession.getStage().getStage() < MultiplayerSessionStage.FURTHER_INTERATION) {
			player.sendMessage("Your actions have declined the duel.");
			duelSession.getOther(player).sendMessage("The challenger has declined the duel.");
			duelSession.finish(MultiplayerSessionFinalizeType.WITHDRAW_ITEMS);
			return false;
		}
		if (Server.getMultiplayerSessionListener().inSession(player, MultiplayerSessionType.TRADE)) {
			player.sendMessage("You must decline the trade to start walking.");
			return false;
		}
		if (player.isStuck) {
			player.isStuck = false;
			player.sendMessage("@red@You've disrupted stuck command, you will no longer be moved home.");
			return false;
		}
		return true;
	}

}

runepouch.java

Code:

package ethos.model.content;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.IntStream;

import ethos.model.content.LootingBag.LootingBagItem;
import ethos.model.players.Player;
import ethos.model.players.PlayerSave;

public class RunePouch extends Pouch {
	public List<LootingBagItem> items;

	public static final int RUNE_POUCH_ID = 12791;
	public static final int MAX_AMOUNT = 16000;
	private static final boolean CHECK_FOR_POUCH = true;

	private final int START_ITEM_INTERFACE = 29908;
	public int selectedItem = -1;
	public int selectedSlot = -1;
	public int interfaceId = -1;

	public RunePouch(Player player) {
		this.player = player;
		items = new ArrayList<>();
	}

	public int[] runes = new int[] { 554, 555, 556, 557, 558, 559, 560, 561, 562, 563, 564, 565, 566, 21880, 9075};

	public void onDeath(Player o, String entity) {
		if (o == null) {
			return;
		}
		handleDeath(player,entity,items);
		sendItems();
		PlayerSave.saveGame(player);
	}


	public static boolean isRunePouch(Player player, int itemId) {
		return itemId == RUNE_POUCH_ID;
	}

	public boolean handleButton(int buttonId) {
		if (buttonId == 116181) {
			closeLootbag();
			return true;
		}
		return false;
	}

	public void openRunePouch() {
		if (!player.getItems().playerHasItem(RUNE_POUCH_ID) && CHECK_FOR_POUCH) {
			return;
		}
		if (!configurationPermitted()) {
			player.sendMessage("You cannot do this right now.");
			return;
		}
		onClose();
		Player c =  player;
		sendItems();
		sendInventoryItems();
		c.getPA().showInterface(29875);
		player.viewingRunePouch = true;
	}

	public void withdrawAll() {
		withdrawItems(items);
	}
	private void removeMultipleItemsFromBag(int id, int amount) {
		System.out.print("Removing multiple items from bag\n");
		if (amount >= 1555) {
			amount = countItems(id,items);
		}
		int count = 0;
		while (containsItem(id)) {
			if (!removeItemFromRunePouch(id, amount)) {
				return;
			}
			count+=amount;
			if (count >= amount) {
				return;
			}
		}
	}

	private boolean containsItem(int id) {
		for (LootingBagItem item : items) {
			if (item.getId() == id) {
				return true;
			}
		}
		return false;
	}
	public long pouchTimer;//just to make sure there is no funny business
	public boolean handleClickItem(int id, int amount, int interfaceId) {
		if (System.currentTimeMillis() - pouchTimer < 2000) {
			return false;
		}	
		if (!player.viewingRunePouch) {
			return false;
		}
		if (!configurationPermitted()) {
			player.sendMessage("You cannot do this right now.");
			return false;
		}
		if (interfaceId >= START_ITEM_INTERFACE) {//removing from pouch
			removeMultipleItemsFromBag(id, amount);
			pouchTimer = System.currentTimeMillis();
			return true;
		} else {
			addItemToRunePouch(id, amount);//adding from inventory to pouch
			pouchTimer = System.currentTimeMillis();
			return true;
		}
	//	return true;
	}

	private int findIndexInLootBag(int id) {
		for (LootingBagItem item : items) {
			if (item.getId() == id) {
				return items.indexOf(item);
			}
		}
		return -1;
	}

	private boolean removeItemFromRunePouch(int id, int amount) {
		if (!configurationPermitted()) {
			player.sendMessage("You cannot do this right now.");
			return false;
		}
		if (items.size() <= 0) {
			return false;
		}
		int index = findIndexInLootBag(id);
		if (index == -1) {
			return false;
		}
		LootingBagItem item = items.get(index);
		if (item == null) {
			return false;
		}
		if (item.getId() <= 0 || item.getAmount() <= 0) {
			return false;
		}
		if (player.getItems().freeSlots() <= 0) {
			if (!(player.getItems().playerHasItem(id) && player.getItems().isStackable(id))) {
				return false;
			}
		}

		if (player.getItems().getItemCount(id) + amount >= Integer.MAX_VALUE || player.getItems().getItemCount(id) + amount <= 0) {
			return false;
		}

		int amountToAdd = 0;
		if ((items.get(items.indexOf(item)).getAmount()) > amount) {
			amountToAdd = amount;
			items.get(items.indexOf(item)).incrementAmount(-amount);
		} else {
			amountToAdd = item.getAmount();
			items.remove(index);
		}

		player.getItems().addItem(item.getId(), amountToAdd);
		sendItems();
		sendInventoryItems();
		return true;
	}

	public void deleteItemFromRunePouch(int id, int amount) {
		if (!configurationPermitted()) {
			player.sendMessage("You cannot do this right now.");
			return;
		}
		if (items.size() <= 0) {
			return;
		}
		int index = findIndexInLootBag(id);
		if (index == -1) {
			return;
		}
		LootingBagItem item = items.get(index);
		if (item == null) {
			return;
		}
		if (item.getId() <= 0 || item.getAmount() <= 0) {
			return;
		}
		if ((items.get(items.indexOf(item)).getAmount()) > amount) {
			items.get(items.indexOf(item)).incrementAmount(-amount);
		} else {
			items.remove(index);
		}
		sendItems();
	}

	private boolean pouchContainsItem(int id) {
		for (LootingBagItem item : items) {
			if (item.getId() == id) {
				return true;
			}
		}
		return false;
	}

	public boolean pouchContainsItem(int id, int amount) {
		for (LootingBagItem item : items) {
			if (item.getId() == id && item.getAmount() >= amount) {
				return true;
			}
		}
		return false;
	}

 @suppressWarnings("unused")
	public boolean hasRunes(int runes, int amount) {
		if(!player.getItems().playerHasItem(RUNE_POUCH_ID)){
			return false;
		}
		return (pouchContainsItem(runes, amount));
	}

	public boolean hasRunes(int[] runes, int[] runeAmounts) {
		if (!player.getItems().playerHasItem(RUNE_POUCH_ID) && CHECK_FOR_POUCH) {
			return false;
		}
		for (int i = 0; i < runes.length; i++) {
			if (!pouchContainsItem(runes[i], runeAmounts[i])) {
				return false;
			}
		}
		return true;
	}

	public boolean deleteRunesOnCast(int runes, int runeAmounts) {
		if (!player.getItems().playerHasItem(RUNE_POUCH_ID) && CHECK_FOR_POUCH) {
			return false;
		}
		if (!hasRunes(runes, runeAmounts)) {
			return false;
		}
		deleteItemFromRunePouch(runes, runeAmounts);
		return true;
	}

	public boolean deleteRunesOnCast(int[] runes, int[] runeAmounts) {
		if (!player.getItems().playerHasItem(RUNE_POUCH_ID) && CHECK_FOR_POUCH) {
			return false;
		}
		if (!hasRunes(runes, runeAmounts)) {
			return false;
		}
		for (int i = 0; i < runes.length; i++) {
			deleteItemFromRunePouch(runes[i], runeAmounts[i]);
		}
		return true;
	}


public void addItemToRunePouch(int id, int amount) {
		int spillover = (countItems(id,items) + amount)-MAX_AMOUNT;
		if(countItems(id,items) + amount > MAX_AMOUNT) {
			amount = amount - spillover;
		}
		
	
		if (countItems(id,items) >= MAX_AMOUNT || countItems(id,items) + amount <= 0) {
			player.sendMessage("Pouch cannot hold more than 16000 runes of a single type.");
			return;
		}
		if (!(IntStream.of(runes).anyMatch(idd -> id == idd))) {
			player.sendMessage("You can only store runes in a rune pouch.");
			return;
		}
		if (items.size() >= 3 && !(pouchContainsItem(id) && player.getItems().isStackable(id))) {
			player.sendMessage("Pouch cannot hold more than 3 different runes.");
			return;
		}
		//if (id <= 0 || amount <= 0) {
		//return;
		//}
		if (id == RUNE_POUCH_ID || id <= 0 || amount <= 0) {
			return;
		}
		
		//int amt = player.getItems().deleteItemAndReturnAmount(id, amount);
		//addItemToList(id, amt);
		
		List<Integer> amounts = player.getItems().deleteItemAndReturnAmount(id, amount);
		
		int count = 0;
		for (int amt : amounts) {
			if (!addItemToList(id, amt, items)) {
				break;
			}
			count++;
			if (count >= amount) {
				break;
			}
		}
	
		resetItems();
		sendItems();
		sendInventoryItems();
	}
	private void closeLootbag() {
		onClose();
	}

	public void withdraw() {
		if (!configurationPermitted()) {
			player.sendMessage("You cannot do this right now.");
			return;
		}
		if (!player.getItems().playerHasItem(RUNE_POUCH_ID) && CHECK_FOR_POUCH) {
			return;
		}
		openRunePouch();
	}

	private void onClose() {
		player.viewingRunePouch = false;
		player.getPA().closeAllWindows();
	}

	public void onLogin() {
		sendItems();
	}

	private void sendItems() {
		if (!player.getItems().playerHasItem(RUNE_POUCH_ID) && CHECK_FOR_POUCH) {
			return;
		}

		StringBuilder sendSpells = new StringBuilder("#");

		for (int i = 0; i < 3; i++) {
			int id = 0;
			int amt = 0;

			if (i < items.size()) {
				LootingBagItem item = items.get(i);
				if (item != null) {
					id = item.getId();
					amt = item.getAmount();
				}
			}

			if (id <= 0) {
				id = -1;
			}
			player.getPA().sendFrame34a(START_ITEM_INTERFACE + i, id, 0 , amt);
			//PlayerFunction.itemOnInterface(c, START_ITEM_INTERFACE + i, 0, id, amt);
			if (id == -1)
				id = 0;
			if (i == 2) {
				sendSpells.append(id).append(":").append(amt);
			} else {
				sendSpells.append(id).append(":").append(amt).append("-");
			}
		}
		sendSpells.append("$");
		player.getPA().sendFrame126(sendSpells.toString(), 49999);
	}

	private void sendInventoryItems() {
		if (!player.getItems().playerHasItem(RUNE_POUCH_ID) && CHECK_FOR_POUCH) {
			return;
		}
		for (int i = 0; i < 28; i++) {
			int id = 0;
			int amt = 0;

			if (i < player.playerItems.length) {
				id = player.playerItems[i];
				amt = player.playerItemsN[i];
			}
			int START_INVENTORY_INTERFACE=29880;
			player.getPA().sendFrame34a(START_INVENTORY_INTERFACE+ i, id - 1, 0 , amt);
		}
	}

	private void resetItems() {
		player.getItems().resetItems(3214);
		player.getPA().requestUpdates();
	}
}